使用Open SSL自签CA跟SSL证书

生成根 CA

1. 为该根 CA 生成一个 4096 位的独立私钥

openssl genrsa -out MyCompanyCA.key 4096

2. 使用生成私钥的自签根 CA

openssl req -x509 -new -nodes -key MyCompanyCA.key -sha256 -days 3650 -subj "/C=US/O=MyCompany/CN=MyCompany Root" -out MyCompanyCA.crt

在纯 OpenSSL 命令行中，如果你想在证书里加上国家（Country）和组织（Organization）等详细信息，你只需要在 -subj 参数里面继续往后追加字段即可。

各个标准字段的缩写如下：

• ​C​：国家 (Country，​必须是 2 个字母的大写国家代码，)
• ​O​：组织/公司名称 (Organization)
• ​OU​：部门名称 (Organizational Unit，可选)
• ​CN：通用名称/所有人 (Common Name)

这些字段在 -subj 参数中通过斜杠 / 进行拼接。

如果还需要一个中间CA就继续给中间证书生成一个独立私钥

1. 生成私钥

openssl genrsa -out MyIntermediateCA.key 4096

2. 生成中间证书的“证书签名请求”（CSR 申请表）

openssl req -new -key MyIntermediateCA.key -out MyIntermediateCA.csr -sha256 -subj "/C=US/O=MyIntermediateCA/OU=MyIntermediateCA/CN=MyIntermediateCA"

执行完后，你会得到一个 MyIntermediateCA.csr 申请表文件。

3. 用 Root CA 批准并签发中间证书
   为了强行给中间证书注入 CA:true 的身份，我们在签发时需要利用 Linux 的 echo 命令塞一个扩展配置文件进去。

openssl x509 -req -in MyIntermediateCA.csr -CA MyCompanyCA.crt -CAkey MyCompanyCA.key -CAcreateserial -out MyIntermediateCA.crt -days 4000 -sha256 -extfile <(echo -e "basicConstraints=critical,CA:true\nkeyUsage=critical,digitalSignature,keyCertSign,cRLSign")

如果你使用的是Windows系统

1.写一个 Windows 格式的临时扩展文件
(echo basicConstraints=critical,CA:true & echo keyUsage=critical,digitalSignature,keyCertSign,cRLSign) > x509.cnf

2. 拿你的根证书(Root CA)对中间CA进行签名（设为 4000 天有效期）
openssl x509 -req -in MyIntermediateCA.csr -CA MyCompanyCA.crt -CAkey MyCompanyCA.key -CAcreateserial -out MyIntermediateCA.crt -days 4000 -sha256 -extfile x509.cnf

3. 删掉无用的临时配置文件
del x509.cnf

给终端/域名生成证书

1. 手动创建一个标准的域名配置文件 server.cnf

[ v3_req ]
basicConstraints = CA:FALSE
keyUsage = digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names

[alt_names]
DNS.1 = www.example.com

2. 为该域名生成一个 2048 位的独立私钥

openssl genrsa -out server.key 2048

3. 生成带有该域名的证书申请表 (CSR)

openssl req -new -nodes -key server.key -subj "/CN=www.example.com" -out server.csr

5. 注入 SAN 域名扩展并正式签发

用中间 CA  进行签名，指定 365 天（1年）有效期
openssl x509 -req -in server.csr -CA MyIntermediateCA.crt -CAkey MyIntermediateCA.key -CAcreateserial -out server.crt -days 365 -sha256 -extfile server.cnf -extensions v3_req

:: 清理终端证书的临时文件
del server.cnf server.csr

6. 合并完整的证书链

copy /b server.crt+MyIntermediateCA.crt MyFullChain.crt

只要把这两个文件传到你的服务器，并在电脑上信任最顶层的 MyCompanyCA.crt就可以了

1. ​fullchain.crt：完整的证书链（里面包含了：终端域名 -> 中间CA）。
2. ​server.key​：域名的私钥。

细心的朋友可能会发现这里并没有合并根CA，是因为在标准的Web证书规范（如 RFC 5246 / TLS 1.2+）中，服务器证书链通常是不包含根 CA 的有两个原因

1. 浏览器/操作系统的信任逻辑是根证书必须是本地已知的

当你的电脑访问服务器时，浏览器会收到服务器发来的证书链。浏览器的验证逻辑是：

• 终端证书是不是中间 CA 签发的？（是）
• 中间 CA 是不是根 CA 签发的？（是）
• 这个根 CA，在不在我本地的“受信任的根证书颁发机构”列表里？

如果根 CA 在本地列表里，浏览器就认为整条链合法；如果不在，即使服务器把根 CA 证书主动发给浏览器，浏览器也绝对不会临时信任它，依然会报“证书不可信”。

因此，服务器发送根 CA 属于多此一举了，客户端完全不需要服务器来告诉它根 CA 长什么样，它只认自己本地保存的根 CA。

2. 浪费网络带宽（增加握手延迟）

根 CA 证书一般比较大（因为通常是 4096 位甚至更高）。在 TCP/TLS 握手阶段，服务器发送的数据越多，网络包可能就需要分片传输，这会直接​增加网页首次打开的延迟*。所以标准做法是尽量精简证书链，不发送多余的根证书。

💡什么时候需要合并进去？

1. ​私有内网或特定客户端（如 Curl、Java、OpenVPN）： 有些私有服务或后端开发代码在对接时，不支持读取本地系统的证书库。它们要求在配置里直接指定一个包含完整闭环（含根CA）的 .pem 文件，通过代码显式加载来建立信任。
2. ​作为归档和完整备份​： 将四张证书打包在一起，方便你完整保存这个多级 PKI 架构的所有资产。

总结来说：如果是​配置标准的 Web 服务器（如 Nginx）让普通浏览器访问，证书链写到 中间 CA 即可（即 server + inter1），根证书单独留给客户端去双击安装。

• 如果是​内网私有组件对接、OpenVPN 部署或代码调用​，直接使用包含了根证书的全面闭环 MyFullChain.pem 会更省心、兼容性更好。

不知道大家在网上有没有刷到这么一句话，叫拧巴的人需要一位怎么赶都赶不走的爱人，这句话就是典型的毒鸡汤。

如果你自己是个拧巴的人大概率会觉得这话特别戳心，甚至觉得对，我就是这样，我就缺这么个人。

但细品之后你会发现他根本经不起现实推敲，先站在宁巴人的角度，说句实在的，拧巴的人之所以拧巴，大多是因为缺安全感，怕受伤。心里明明很在乎，嘴上偏偏要硬撑，就是刀子嘴豆腐心，明明舍不得，非要故意冷淡，故意找茬，故意把人往外推。

他们不是坏，是真的不会好好表达，总觉得我把最难听的话，最冷漠的样子都摆出来了，如果你还不走，那才是真的爱我。他们心里其实一直在等一个答案，就算我这么别扭，这么难搞，你也不会丢下我。所以这句话一出来，简直说到心坎里了，感觉终于有人懂拧巴人的委屈和不安。

但你不妨换个视角，站在那个被你赶的人身上看看，人家一开始也是真心喜欢你，想好好跟你走下去的，可你一次次冷暴力，一次次说反话，一次次把人推开，一次两次，人家能忍能哄能自我说服，那十次八次呢，人家也是会有情绪有自尊会累的，你以为这是在试探真心，在对方眼里就是一次次被否定被消耗被不珍惜。你一次，对方疼一次，你十次，对方的心早就凉透了。

所谓怎么赶都赶不走，听起来浪漫，实际上是在要求另一个人无底线包容你的幼稚不成熟。没有人天生就该承受你的别扭，你的臭脾气。真正爱你的人，不是赶不走，是舍不得走，可再舍不得，也扛不住你一直往外推，很多拧巴的人，最后都在后悔爱你的人被自己赶跑了，后来回头才发现，再也遇不到那样的人了。

最近又有一个和这条拧巴毒鸡汤类似的话题叫《幸福就是每一个犟种炸药包小姐都会遇到一个对你毫无脾气，愿意为你低头，哄你开心的好脾气先生》；你看看这话是人能说的出来的吗？我估计AI都说不出这么离谱的话，照上面这句话的逻辑，家暴的人需要一个打不死的爱人，抢劫的人需要一个不会报警的银行，杀人犯需要一个捅不死的人；那我是不是可以翻译成幸福就是每个拳击手先生都会遇到一个抗揍的赶不走还会哄你开心的沙包小姐？如果是这个样子的那我说句实话，你炸药包小姐和打火机先生是最般配的了，就别霍霍好好先生了，人家好脾气先生就应该匹配一位温文尔雅女士，还不是天天被你炸，被你怼，被你拿情绪当武器反复折腾。

大家真的别再被这种话洗脑了。那些把自己的坏脾气、没教养，控制不住情绪包装成性格，只需要被偏爱的人，本质上就是自私。

爱情从来不是一个人无限退让，另一个人肆意放纵。好的感情是互相迁就，不是单方面当受气包。拧巴的人对方可以引导你但是你要还是这样那就不留恋了，你可以有脾气，可以犟，可以拧巴，但请别把别人对你的爱，当成你随便发泄的底气，别把爱你的人耗走，也别让你的拧巴，弄丢了最该珍惜的人。

别指望有人能永远赶不走，再深情的人也会累，谁都没有义务，一直包容你的敏感、你的口是心非、你的反复试探和推开。

感情是相互珍惜，不是单方面的兜底和消耗，别把别人的爱，当成你情绪内耗的牺牲品。

等你把一个人耗走了，又回头说人间不值得，其实不值得的从来不是人间，是你从不珍惜的模样。

读过一句话他说某天你会无端的想起一个人，他曾让你对明天有所期待，但是没有出现在你的明天里，然后我最近看到了后半句：“他会往后的岁月当中给你更长久的幸福，虽然它不曾来过你的青春”

为什么我们说爱情自有天意，为什么我们说缘分真的很奇妙，那有些人他就是会陪你一程，而有的人会注定伴你一生，说到这的时候肯定会有一种批评的标准
把前任归结为错误的人，把结婚归结为正确的人。而我认为实际上的情况只是你在不同的时间里遇见了不同的自己，在不同的际遇中发生了不同的爱情。

同样我也讨厌那种一生只爱一个人的苦情剧本，因为我不想做一个被过去所消耗的人，也不会想用过去的影子来丈量现在爱的人，我想我的爱不会因为给过别人就减少，也不会因为没有给过别人而增加它更像是一种能力，就像有一句话说的樱花树下站谁都美，我的爱给谁都热烈。

我觉得好的爱情不一定是至死不渝，但是一定是当时不渝的，就是在相爱的那段时间里面你都真诚的全然的愿意和这个人一同去承受人世的危难，尊重对方不欺瞒，不利用。

我想千千万万个人就会有千千万万种对爱的定义，爱可以是乍见之欢，是水中捞月，也可以是细水长流，是久处不厌，它是永恒的同时也是流动的是仿佛永远分离却又终身相依；而爱的神圣之处就在于它是世界上唯一能与理性抗衡的力量，就像迪更斯说的我爱他是违背常理，是妨碍前程，是失去自制，是破灭希望，是断送幸福，是注定要尝尽一切的沮丧与失望的；可是一旦爱上他，我就再也不能不爱他。

还有另外一段话我也很喜欢他说：“我不是不知道爱你的成本很高，我不是没有考虑过前路的遍地棘，只不过对于我而言，关山难越抵不过山后的无边风月，完人难寻，难不倒我对你的暮成心许，你从来不是我权衡利整之后的选择，而是我怦然心动之后，明知不可为而为之的决心，我想我们都能够真诚的，坦荡的对待每一份关系，如果足够幸运的话，我们会一次次的坠入爱河，与同一个人”。

希望大家不要因为分手了就一辈子被困在过去了，也不要因为分手了就否定曾经真实的爱过，我依然相信爱情的神圣，对爱情的美好持有憧憬，因为万物一直在变，在生理学当中多巴胺的作用使得热恋期只有三个月到六个月，那我想真爱就是可以和同一个人一次又一次地相爱。不是因为我只能爱他，而是因为我们每一天都在重新选择对方。

我们都说热爱可抵岁月漫长可如果岁月一直漫长呢？

我第一次听到热爱可抵罗月漫长这句话是在初中的时候，我当时觉得它说的挺好的
一个人如果真的能够找到自己的热爱那么对他来说所有的困难都会变得很值得

可问题就在于如果你一直没有被理解，一直没有被看见，这份热爱真的可以抵住寂静无声的悠长岁月吗？
之前看过一场辩论赛他的辩题名称叫做《选择多数人的生活方式是不是更省力的人生路径？》
我的立场是反方，因为我朴素的直觉告诉我，如果你真的能够找到自己热爱的事物那么它就与少数人和多数人没有关系了
因为不管有没有人支持，有没有人肯定，这一路上有没有人同行，也都一直会是你喜欢的事情。

可是后来我发现了一个问题并不是所有人都能够找到自已的热爱，而耳找到热爱这件事情本身他也是一件很困难的事情，而且就算你真的找到了你要能够确认自己真的热爱它，就会变成一个更困难的事情
我一直都很喜欢雪山，在我高中的时候去过一次稻城川西，看到那三座巍峨哦的神山出现在我面前的时候，我确定我大概在未来的很长一段时间里，我都会义无反顾的奔向它
可是后来我发现一件有趣的事情，就是那些很多包括我在内的很多旅客，我们爱的只是云层散开之后的雪山，因为在那拉提当那个云雾把雪山遮住的时候
我发现我的内心会产生失望、烦躁和郁闷，可是如果我真的爱一座山，那么不管他是否露出真容
我都应该爱他，就像明永冰川山脚下的那些藏民一样，他们不会去计算日照金山的概率，只知道只要山还在那儿，那就永远会是他们心中至高无上的信仰，哪怕山神一年四季并不会馈赠他们凡次对望，但他们永远会风雨无阻的守护在那里。

所以热爱可抵罗月漫长一个可抵岁月漫长的词语它究竟会有多重多重呢？

在这样的评价标准之下我开始问自己那我有没有热爱着些什么东西呢？
然后得到了一个让我很失望的答案
从小我听到很多的一个声音是
你要尽可能的努力，你要在正确的年纪做出正确的选择

好像社会总是会对男孩说
你要去发现，去闯荡，去开拓，哪怕有可能会犯错，你要功成名就，你要事业有成；而对于女孩则更多的是你要找一份稳定的工作有一份稳定的收入，有一个圆满幸福的家庭，这个好像就是一个对平凡的普通人来说最好的归宿

我不能说这样的声音他是不是善意的，也不能评价它到底是好是坏，但当这样的一种声音在我的耳边绕的时间太长之后，它就变成了一种桎梏

就像我有的时候会在想我是不是真的喜欢3D建模跟动画呢？
如果当时我的各位老师他们并没有说你其实做的挺不错如果我身边的大人们，没有说他是一个聪明的孩子，我还能不能够在人前非常自信天方的说出我喜欢动画我想或许不能吧？

我基至也不敢说我热爱建模跟动画，因为每当我产生这个念头
我询问我自己我是不是热爱建模动画的时候
我的脑海当中就会蹦出一个声音：“不，你其实已经被看见了”
所以你当然可以说热爱可抵罗月漫长
那是因为你已经成功了，可如果你没有成功呢？你能够说这是一个比稳定的生活更好的选择吗？

那我可能没有办法去回答这个问题

所以你看只要稍微往前推一步，那些看起来好像我的热爱，都只是因为得到了一个正向的反馈和结果，而追逐热爱这件事情本身，好像也变成了只是为了得到那个结果，这件事情让我无比的沮丧好像我从来没有纯粹的热爱着任何事物

可真的是这样吗？

我依然会在生活的间隙举起相机
哪怕它可能最后不一定会变成一个视频，哪怕这个视频他就算发出来了，也不会有那么多人喜欢和看到，但是我依然在做
因为做这件事情本身让我觉得很开心，包括在那个我身边人看来性价比超级超级低的逐顿动画，我依然会为他投入非常多的时间和精力，只是因为我觉得这是让我快乐的事情。

所以可能我没有办法做到像明永冰川脚下的藏民那样，他们有这么纯洁这么至高无上的信仰和爱，但对于我来说，在我还没有办法确定，能不能够看见那个雪山的峰顶的时刻，我依然选走向它。

在每一次不如意的跌倒之后依然爬起来继续往前走，爱就已经存在了

人们太习惯于用一个结果去评价意义，好像只有一个成功的人，他的热爱才是值得，才是被肯定的，好像只有这样的人他才能够说出热爱可抵岁月漫长这样子的心灵鸡汤可人们忽视了在这个过程当中在被看见之前的日子

所以我想分享一句我很喜欢的一句话
他说我终于知道我为什么要做一件事情，因为做这件事情让我开心，而一个好的结果，只是让这份开心变成了一百倍。

很多时候并不是先有了纯粹的爱才有了坚定的行动而是在行动当中持续的投入才构建出了爱的实体，所以其实爱一直都存在只是当那个正向的结果出现的时候爱才被清晰的看见才能够被坚定的相信。

所以再回到最开始的那个问题
你说当我们不被理解不被看见的时候你要怎样才能坚持下去呢？
那我想我的答案或许就是你要淡化结果的重量你要把价值和意义平摊到这个过程当中同时你要去思考在这个过程当中我主动拥有的获得的东西是什么？而不是外界被动赋予给我的东西是什么，只有当这套评价体系牢牢的被抓住在我自己手里的时候，我才能够决定我想要过上什么样的人生，想要变成什么样子的人，我才能够找到我的热爱然后说出那句话热爱可抵罗户漫长。
最后想和所有和我一样产生过相同的困扰又或者现在正在经历这样的困扰的人说：“祝你拥有对抗岁月漫长的勇气也请坚定的相信属于你的那个瞬间终将降临”

在感情中谈得久比谈得多的更吓人？

最近看到一个话题为什么谈得久的，比谈得多的更吓人？

很多人会下意识觉得

谈得多的人经验丰富，套路熟练见得多，走得快；但现实往往相反，真正让人压力大的可能是那个上一段谈了很多年的人。

为什么呢？
首先谈得多，是广度问题
谈得多的人，经历的是样本积累，他们更容易知道自己要什么，也更快识别不合适

但谈得久的人不一样谈得久，是深度问题，一段关系如果持续很多年它已经不是一段恋爱而是一段生活结构在生活习惯、节奏、价值观、对未来的设想都曾深度绑定过一个人。
这不是简单的“谈过”这是融合过而融合过的人很难完全抽离

其次是沉没成本当一个人投入了大量时间、青春、情感、甚至家庭期待，哪怕关系结束了那份投入感依然不会立刻消失，就像网友说的有些人嘴上说放下了，但只要前任有风吹草动他的情绪就会瞬间起伏

而且谈得久的人，更容易在潜意识里去做比较
如果一个人曾经和另一个人走过多年
你们现在的每一次争执
每一个习惯冲突
都会无意识被放在对照组里
“以前不是这样”
“以前我们会这样处理”

这才是压力来源

如果一个人经历多年感情已经认真复盘过、成长过、承担过、释怀过那他反而更成熟

但如果只是被动分开，只是时间推着走，只是形式结束，那段关系就会像一个未关闭的程序
有趣的是，谈得多的人有时反而更知道什么叫不合适，他们不会轻易理想化，不会把你当作命运，不会把感情当救命稻草；当然也可能更冷静

你与其问他谈得久会不会更吓人？
不如问他有没有能力为过去负责？他有没有真正完成那段关系？他是否能在你面前是一个完整的人，而不是残影？

时间从来都不是问题而未被消化的情感才是

你无法和一个人的过去所竞争，你只能看他有没有把未来给你。

如果一个人提起过去时不逃避、不神化、不仇恨，只是平静叙述那说明他真的走出来了。

如果一个人对过去避而不谈或者过度美化那你就要小心

最后，谈得久不可怕，谈得多也不可怕，可怕的是一个人没有完成自己的情感成长就急着进入下一段关系

爱情不是接力赛，它更像升级系统，如果上一关没有过，下一关一定会重考

你不需要害怕时间，你只需要确认你爱的是一人已经完成的人，还是一个还在清理旧战场的人。

那些你未完成的课题，命运会让它反复出现，直到你给做出新的答案。

搭建后端Subconverter

docker compose部署

项目地址：https://github.com/tindy2013/subconverter

Docker官方指引：https://github.com/tindy2013/subconverter/blob/master/README-docker.md

#docker部署
docker run -d --name subcon --restart=always -p 25500:25500 tindy2013/subconverter:latest
​

#docker-compose部署
subconverter:
    image: tindy2013/subconverter:latest
    container_name: subconverter
    restart: always
    ports:
      - 25500:25500
​

MetaCubeX版后端

subconverter-mate:
    image: ghcr.io/metacubex/subconverter:latest
    container_name: subconverter-metacubex
    restart: always
    ports:
      - 25501:25500
​

#docker部署
docker run -d --name subconverter-metacubex --restart=always -p 25501:25500 ghcr.io/metacubex/subconverter:latest

• Subconverter负责渲染分流规则，后端原版作者是tindy2013，但一直不支持vless，后来MetaCubeX修改了作者的后端，支持vless hy2等

搭建前端Subweb

项目地址：https://github.com/CareyWang/sub-web

配置前端

如果用docker搭建，需要配置前端之后，重新build镜像。

# Clone项目到本地
git clone https://github.com/CareyWang/sub-web.git
cd sub-web

# 编辑.env配置文件
vi .env

# 修改后端地址、短链接地址
# API 后端
VUE_APP_SUBCONVERTER_DEFAULT_BACKEND = "你的后端地址"

因为我这里不需要短链因此其他不做配置

🚀 使用

开发环境

# 启动开发服务器
yarn dev

访问 http://localhost:5173/ 查看应用。

生产构建

# 构建生产版本
yarn build

构建完成后，dist 目录包含所有生产文件。

🐳 Docker 部署

本地构建

如需修改代码并自定义构建：

# 构建镜像
docker build -t subweb-local:latest .

# 运行容器
docker run -d \
  -p 58080:80 \
  --restart always \
  --name subweb \
  subweb-local:latest

Docker Compose 部署

使用 Docker Compose 一键部署完整服务栈（包含 MyUrls 短链接服务）：

# 进入 services 目录
cd services

# 编辑 .env 文件，修改端口和域名配置
# 默认配置：SUBWEB_PORT=58080, MYURLS_PORT=8002
vim .env

# 启动所有服务
docker-compose up -d

🌐 部署

Nginx 配置示例

配置 Nginx 作为反向代理和静态文件服务器：

server {
    listen 80;
    server_name your-domain.com;

    # HTTPS 重定向（可选）
    # return 301 https://$server_name$request_uri;

    root /var/www/sub-web/dist;
    index index.html index.htm;

    # SPA 路由支持
    location / {
        try_files $uri $uri/ /index.html;
    }

    # Gzip 压缩
    gzip on;
    gzip_min_length 1k;
    gzip_buffers 4 16k;
    gzip_http_version 1.0;
    gzip_comp_level 6;
    gzip_types
        text/plain
        text/css
        text/javascript
        application/json
        application/javascript
        application/x-javascript
        application/xml
        text/xml;
    gzip_vary on;

    # 静态资源缓存
    location ~* \.(css|js|png|jpg|jpeg|gif|gz|svg|mp4|ogg|ogv|webm|htc|xml|woff|woff2|ttf|eot)$ {
        access_log off;
        add_header Cache-Control "public,max-age=86400";
        add_header Vary Accept-Encoding;
    }
}

# HTTPS 配置示例（可选）
server {
    listen 443 ssl http2;
    server_name your-domain.com;

    ssl_certificate /path/to/your/cert.pem;
    ssl_certificate_key /path/to/your/key.pem;

    # SSL 安全配置
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;

    root /var/www/sub-web/dist;
    index index.html index.htm;

    location / {
        try_files $uri $uri/ /index.html;
    }
}

get方式Url长度问题

#nginx设置
client_max_body_size 24M;
client_body_buffer_size 128k;

client_header_buffer_size 5120k;
large_client_header_buffers 16 5120k;

谈恋爱真的就是一个很好的真诚的面对自己内心的时机，恋爱谈到最后你会发现问题的核心跟对方是一个怎样的人根本没有太大关系，对方可以很好、也可以很坏，可以是爱你的、也可以是不爱你的，但这些都不重要。

真正重要的是你能在这段关系中照见出一个怎样的自己，然后你才会切实体会到，原来这个世界所有的关系、矛盾或问题，本质都是我跟自己之间的关系。一个人倘若不谈恋爱，不喜欢上一个人爱一个人，大概无法意识到自己居然有那么多脆弱、自私、怪异、偏狭和不快乐。人在独处时，总容易把自己想得高尚和谦卑，只有当另一个人来到你的生活中时，你才会不断的破坏和重建自我。所有的问题和冲突，本质是你跟自己的内在的问题、冲突。不是要让你发现对方是一个什么人。而是让你发现，我原来是一个这样贪嗔痴慢疑这么多的人。爱人眼里不仅有甜蜜和热烈，也能找寻到失落与不堪。到头来，即便再固执也会发现：自我，终究只是多么小的事，它甚至是流动、不定形的，放弃部分的自我，不见得那么可怕

人总是后知后觉的

打破以往对自己的认知，明白不是因为对方让你内耗，而是因为自己本身匮乏，不完整不圆满，内核不够丰盈自信。

我们每个人所认知的世界是一个被自己用主观感受、认知和滤镜包裹住的世界，亲密关系让你愿意亲手主动打碎这一层层的主观滤镜，并看到一个真正清晰、客观的现实世界。

亲密关系所代表的东西绝不仅仅只是两个人之间的关系这么简单，它没有这么狭隘这么私欲这么浅薄，它是一种更宏观高级的真正清晰的、我们自己跟自己之间的关系

自己跟他人之间的关系，自己跟世界的关系。所以都要爱上镜子里更好的自己。

当你开始对一个人产生了“想要更亲密”的欲望时，其实你心底涌动的不仅是喜欢，还有对自我的试探，仿佛对方的回应是一面镜子，能照出我们是否值得被爱。

于是你就会在友情里忍不住追问“为什么他总对我有所保留”。爱情里反复纠结“他是否真的在乎我”，

这种欲望像一根透明的丝线，一端拴着期待，另一端劫勒紧了自己的喉咙。我一直觉得，我对人好，以诚待人，别人自然会以诚待我、后来我才知道人性复杂，有欺骗，有猜忌，有背叛和伤害，人心多的是善变，大部分人不是所有真心都能换来真心，

不要把任何个体想象的那么美好，所有的关系都取决于权衡利终之后的选择。任何试图改变别人来满足亲密欲求，本质上是一场对安全感的追捕。我们误以为只要对方多靠近一寸，孤独就会少一分。可现实往往是：你越用力拽着丝线，对方越感到室息那些要求朋友秒回消息的焦虑、期待伴侣时刻陪伴的执念，最终变成关系的裂痕。真正的亲密，从来不是单方面调整距离的游戏、而是两颗心自发共振的频率和灵魂上的共鸣。欲望本身无罪，它是生命的火种。但若将欲望的满足完全寄托于他人的改变便如同把火种交给一阵风，风的方向从不因你的祈祷而固定。

你渴望的亲密，或许藏在你从未正视过的角落：那个总是优先考虑他人感受的自己是否忽略了与自己的对话？

若他始终不愿靠近，也许你需要先练习“一个人也能完整”

若他总是若即若离，或许你该诚实地问自己：“我是否在用他的存在填补自己的空洞”？

亲密感的本质，不是物理距离的缩短、而是两个独立灵魂的彼此映照，

当你停止用他人的回应丈量自我价值时，关系才会显露出它最终的样貌。在这漫长的人生里，我们都在寻找那个能与自己同频共振灵魂共鸣的人。

内核足够完整，便不会对关系投射错位的期待。亲密关系中极大的执看，是总过度强求在对方心中占有特别的一席之地。总想争抢到对方灵魂里足够重要的位置，来安顿自己。最好是不可替代的存在，能被对方深深看见：

好像唯有这样，自我存在的价值才得以被证明。这种过度执着的背后，是藏着对自我很深的否定感的，你把对方放置在自己心里过于重要的位置上。某种程度上也许视对方为救赎，拿对方的存在，填补自己内在的残缺。

一个内核完整而爱着自己的人，内在主体，安放的一定是自己。那是你的心之所在是无条件接纳自己、支持自己、认可自己本然存在的灵魂内核。当她还尚有残缺，不要企图去索取外部世界的存在来填补，她外在一切都救不了你。当自我不再匮乏，对外部世界是不会有过度执念的需求的，只在缘分的安排下迎接命运的一切馈赠，在每一次相遇中，把内在的光再分享给这个世界多一些。这时再反观对方，那些你因匮乏而产生的过度期待，也会自然被消融。

你会明白，对方与你再亲密，他的内核也依然是他自己。一段关系，我们不能试图去改变任何人，要从彼此错位走向重新规整与成长是要经历剧烈波动的。就像一次兴师动众的大扫除一样，经历阵痛是必然的。但那是段好的关系的必经之途。

当两个健全的灵魂爱着彼此，即便不得不暂时别离，可要正在走向各自内在更圆满的道路上，也值得为此感到欢喜。

我想我们都能更坚强更果断，能拥抱的时候就不要争吵，能行动的时候便不要犹豫，能见面的当下请不要推辞，答应自己的事就努力做到，想要去的远方就尽力抵达，要记住在告别前抓得更紧一点，在相遇前变得更优秀一点。

大部分人在这个社会和资本共同编制的剧本下强行推着往前走，女生想要浪漫、仪式感、情绪价值

不是因为她天生很作而是这个时代告诉女人你值得被宠你值得被仪式感包围你要有高品质的生活否则你就是不被爱

男生呢拼命挣钱赚钱买房、买礼物不是因为他多爱物质而是这个社会从小就灌输男人你爱她你就得有钱

你负责赚钱，他负责幸福你不能软弱你不能倒下

于是女人活在“我是不是值得被爱”的焦虑当中；男人活在“我能不能撑起这个家”的压力之中

你和你对象之间一个不断索要“爱的证据”一个不断证明“我能担当”

但是我们从来都没有问过对方 你累不累？你要的是什么？

我们都以为我们在经营感情，其实我们只是在完成KPI

你负责赚钱，我负责美丽，你负责稳定，我负责情绪，你负责不出轨，我负责不任性

可是感情哪里是绩效指标能完成的？它需要的是真诚是理解、是两个人坐下来放下剧本看清对方真实的样子

所以我这次蛮想跟兄弟们说一下的

咱们不是提款机也不是情绪垃圾桶不是社会标准下的工具人

这个时代它喜欢贩卖焦虑，它喜欢制造对立

但是我们要学会清醒，学会拒绝被绑架

我想跟所有人说感情里面最重要的是不是索取啊，而是同甘共苦一起打天下

我们网上所看的那些描绘美好爱情与婚后景象的视频，绝大多数都是围绕看男性如何对女性极尽宠爱，体贴入微，细心关注女性的每一个细微之处所展开，却鲜有镜头转向展现女性如何回馈以同样的深情，如何体贴入微地理解与支持男性。这难道不是大数据个性化推送的结果吗？而面男性的短视频推送中，也一样存在类的倾向，只是内容恰好相反

刷视频真的不要太认真，有一些当成笑话看看就行了，别人做内容是为了挣钱我们就别傻乎乎的把里面的一些道理当成过目子的真理

天底下最可悲的事情就是两个人活了一辈子，生活了一辈子，忙活了一辈子，却不知道对方想的是什么，自己究竟要的是什么

焦虑型依恋人格是依恋类型的一种，主要表现为在亲密关系中容易产生不安和焦虑情绪，具体特点如下，对亲密感过度渴求比是希望和伴侣保持紧密联系，害怕被冷落或抛弃。

比如频繁发消息、打电话确认对方状态，敏感且易猜疑。

对伴侣的言行过度解读，比如对方回复消息慢了，就会担心是不是自己哪里做的不好，或者对方是不是不爱自己了。

情绪不稳定，在关系中容易患得患失，一会儿觉得对方很爱自己，一会儿又陷入不安，情绪波动较大。过度付出与索取，可能会为了维持关系而过度迁就对方，但同时又会不断向对方索取情感回应，希望得到更多的关注和肯定。

这种依恋模式通常和童年时期与抚养者的互动有关，比如抚养者对孩子的需求回应不稳定，时而关心时而忽视，孩子就可能形成这种对关系缺乏安全感的模式。

不过，焦虑型依恋人格是可以通过自我觉察和调整，以及在安全的亲密关系中逐步改善的。

如果你是焦虑型依恋人格，请先亲亲抱抱此刻的自己，那些不安与猜疑都不是你的错，只是过去的经历在心里种下了缺乏安全感的种子。

别害怕你的敏感与渴望，被爱都是珍贵的情感，在关系里，你无需时刻紧绷着去确认对方的心意，也不必为了维系感情而过度消耗自己。

真正对的人，会愿意接纳你所有的情绪，陪你慢慢抚平内心的不安。

你值得被坚定的选择，温柔的呵护，试着多给自己一些耐心和宽容，从今天起，和自己和解，也和关系和解，安全感会在你爱自己的过程中一点点生长起来。

为什么之前为了一个人付出了我的真心，哪怕对方明确不喜欢我，但是我还是会有种不甘心呢？

其实这种不甘心的情绪核心可以用沉默成本来解释，你在这段关系中投入的真心、时间、精力等已经无法收回，而这种你付出却未得到预期回报的落差，会让人本能的产生不甘，甚至想通过继续投入来挽回损失。具体来说，沉默成本对这种情绪的影响体现在以下几点

1、投入的不可逆转性放大了失落感。你付出的真心是实实在在的情感投入，包括为对方着想、迁就对方，甚至牺牲自己的需求等，这些投入一旦发生，就像泼出去的水，无法收回，当对方明确不喜欢你时，这些投入失去了被回应的可能性。这种白费功夫的感觉会直接转化为不甘心。你会忍不住想，我都付出这么多了，怎么会是这个结果？

2、对损失的本能抗拒人天生有损失厌恶心理，相比获得，我们更难接受损失，沉默成本越高，这种厌恶感越强，你为对方付出的真心越多，就越难接受这段感情。没有结果，这个损失不甘心，本质上是一种抗拒接受损失的心理，你潜意识里可能还希望通过某种方式捞回成本。哪怕明知对方不喜欢，也忍不住纠结，如果我再努力一点，会不会不一样？

3、自我价值的隐性关联。当我们为一个人付出真心时，往往会不自觉地把对方是否接受和自我价值挂钩。沉默成本带来的不甘心，有时也包含对自我价值被否定的在意。你可能会想，我付出的真心是真诚的、有价值的，为什么不被认可？这种对自我投入价值的质疑，会进一步强化不甘心的情绪。

简单说，不甘心就是沉默成本在作祟，你放不下的不仅是对方，更是自己已经投入的那些无法回头的真心，以及对付出就该有回报的执念。

你越过了朋友这条线，明确拒绝了我。至此我知道，我真心追求的结果已成为沉没成本。但是如果我在遇到下一段感情中，我成长了，会更好的处理这些关系，那么我认为它将变为一个机会成本，因为它将使我成为更好的人，也让我遇到更好的人。

在追求有好感的对象时有一种最容易被忽略的情况你觉得进展特别顺利就差最后一把火了可这时候其实已经错了你该停下来回想看看有没有出现这些情况

1、你给她发消息，她会回偶尔也会主动找你甚至能聊到凌晨两三点你窝在被子里心花怒放觉得这次背定不一样，却没发现她回复的次数越来越少，主动开启话题的频率也低的可怜

2、她会跟你说很多事，尤其是那些负能量的情绪甚至掏心窝子讲前任讲感情里的创伤与背叛，你以为这是信任觉得自已是最懂她的人可心里总有种说不清道不明的迷茫好像离她很近又好像隔着什么

3、你们的聊天记录里10句有9句在说她的事，她的倾诉欲像开了匣却很少主动问起你的生活，偶尔的关心浅尝止与其说是在意不如说是礼貌，你们聊了很久却始终停在好友的安全区没有半分暖味的腻歪更谈不上恋爱的前奏这种状态要是超过40天就别再自欺欺人了

4、每当你想突破一下说点暖味的话说“梦到你了”给她起亲密的昵称，她却总是在装傻像隔着一堵无形的墙见面永远是吃饭、逛公园单独看电影的机会屈指可数更别提情侣间的互动和身体接触。她总找你泄负能量，聊起感情却一脸佛系常常把智者不入爱河，谈恋爱没意思挂在嘴边，让你不安却又会让你觉得我是特别的能温暖她

5、她会在你面前毫不各的夸别人对前任更是一副又爱又恨的模样这类人多半慕强又颜控总把高学历高颜值挂在嘴边说的多了你反而觉得她愿意跟我说这些是不是还有希望？

你之所以放不下不过是因为她没冷漠拒绝你会回消息能约出来态度算不上敷衍，你总觉得再努力一点就能捕破窗户纸可醒醒吧这不过是你的幻觉，她对你大概是60%的朋友加40%的工具人，不是赤诚的友谊而是带着点算计的需要，需要一个倾听者、需要一个情绪垃圾桶、需要一个能让她、需要一个能安心展示脆弱的人

她未必是故意的但在潜意识里把你放在了不够喜欢但有用的位置

真正喜欢你的人会紧张你的情绪，会好奇你的过去，会想知道你今天吃了什么，开心不开心，而不是只把你当情绪出口

真正喜欢你的人不会说不想谈恋爱，反而会悄悄释放可得性，，生怕你误会他对感情没兴趣

真正喜欢你的人不会总在你面前夸别人提前任他会忍不住赞你会旁敲侧击的试探是不是有很多人喜欢你？

如果她只会说你人真好，那基本是把你当工具人实锤了

真正能走到一起的人很多都是一拍即，合暖味的信号从刚认识就藏不住两三周就能见分晓

那些看起来热情甚至有点依赖你让你上头的感觉未必是喜欢可能他只是需要一个好朋友

可是你又很缺她这个好期友吗？

快醒醒吧！这不是暧昧期，这只是好朋友。

你现在的状态更像是在和过去的投入较劲，而不是对他这个人会抱有强烈的心动。以前刚认识时，聊天会让你快乐，主动分享是发自内心的期待，但现在主动变成了负担，他的回应让你失落，甚至觉得卑微，你反复提到他的敷衍、不主动。这些细节像沙子一样磨掉了最初的好感，连你自己都意识到滤镜碎了，丢失了好感。

你知道吗？其实真正的喜欢，是想起对方时会带着期待和暖意，而不是纠结他为什么这样对我，我该不该放弃，是愿意主动，但不会因为主动而感到委屈，更不会在对方的冷漠里反复内耗。

你现在还没彻底放下的，可能是不甘心，不甘心自己的真心没被珍惜，不甘心付出没结果，其实你心里早就有答案了，只是还在和这份不甘心较劲，你舍不得的不是他这个人，而是那个全力以赴却没被善待的自己是那些如果再努力一点，或许会不一样的幻想。

但这种不甘心和喜欢是两回事，前者是对过去的自己的心疼，后者是对眼前的他的向往。

而真实的情况是，他对你的态度，从来不是你做的不够好，而是你不在他的选择里，你主动找话题，热情回应，甚至委屈自己去讨好。这些在你看来是诚意，在他那里可能只是可以随意对待的负担。

她的敷衍不是偶然不主动，也不是矜持，就是单纯的没那么在意，这不是你的错，只是你们对彼此的在意程度本就不在一个频道上。

所以答案其实很明显，你对她的喜欢早就被一次次的失望和消耗磨得差不多了，剩下的那些拉扯更多是惯性和执念，你现在的放不下更像是在和自己赌气。

就像手里攥着一块融化的冰，明明已经冻得手疼，却还在等他重新变成你想要的形状，可冰化了就是化了人的心不在了再怎么悟也暖不热。

承认这一点，不是否定过去的心动，而是放过现在的自己，毕竟连你自己都能感觉了，继续下去，快乐已经远远少于委屈了。

真正的清醒是承认，不是所有付出都有回响。你已经给过她无数次机会，也对得起自己的期待了。

现在该轮到对自己负责了

把花在等她回复的时间用来健身，把琢磨他心思的精力用来搞事业，把讨好她的热情分给身边真正在意你的人。你要明白，好的关系从来不是求来的，而是吸引来的。

当你不再围着她转，开始发光的时候，自然会有人看到你的亮，主动向你走。来到那时你会发现，现在纠结的放不放下，不过是人生里一段小小的插曲，而你值得更好的风景。

别再用她的冷漠惩罚自己了，你的热情和真心应该留给那个会小心翼翼捧住他们的人，现在先把他们收回来好好爱自己别再让那些无谓的纠结消耗自己了，你已经在这段关系里足够真诚也足够勇敏这就够了

放下不是认输而是给自己一个重新开始的机会去做让自己开心的事去爱值得的人去把日子过得热气腾腾，你本来就很好值得被认真对待也值得更轻松的幸福往前看那个懂得珍惜你的人正在路上呢！

你值得被人放在心上，值得被真诚回应，当你开始好好爱自己时那些对的人对的感觉，自然会慢慢向你靠近，放“过去”一条生路也给现在的自已一个重新开始的机会吧

当主动只换来失望时，放过自己是最好的选择

别再把自己当“需要别人施舍关心才能活”的人了。你饿了，就自己给自己做顿饭；冷了，就裹紧外套；想说话了，哪怕对着镜子说，也比对着一个忽冷忽热的人强。你不是谁的附属品，不是“需要被关心才能证明存在”的影子。

你值得的爱，是“我看到你了，我接住你了，我不会让你一个人了”。而不是现在这样，让你在“她到底爱不爱我”里反复煎熬，让你觉得“自己连被好好对待都不配”

省时间版：Windows11自动下载的网卡驱动有问题具体是什么问题我也不知道，反正用驱动精灵更新了一下网卡驱动就好了。

两个月之前迷上了玩CS2之后我发现每次晚上玩CS的时候都会无缘无故的延迟跟丢包，起初我以为是软路由的QOS策略有问题，我分别把5E、完美以及官匹的数据包抓了出来把数据头添加到自定义游戏规则里面并把游戏数据优先级调整成0，调整完好了两三天又开始出现丢包，我立刻登录软路由的后台看了一下软路由负载CPU占用百分之二，并且宽带也没有用满，我就纳闷了为什么会无缘无故的丢包，我开始怀疑不会是交换机的问题吧，我去机柜里把我电脑的网线拔了直接插软路由上当天晚上好了一点丢包没这么严重了但是还是有，至少是能玩了。

过了两天之后白天我先是打两把英雄联盟然后再玩的CS，玩英雄联盟的时候一点问题都没有一玩CS就开始丢包，我在想不会是我电脑CPU满了之后CPU算不过来产生的DPC延迟吧，我那把结束了之后去Google调整本机网络的DPC优先级，重启了之后继续开游戏发现并没有什么用之后开始怀疑网线的水晶头，我重新打了水晶头之后好像有点好转了但还是有时不时丢包的情况我就想就这样吧

就这样我玩一半个月情况又越来越严重了我在想不会是我软路由的网卡坏了吧。我去淘宝买了一张10G的双口网卡跟一对SFP10G电口模块回来换上，问题依旧，我已经郁闷了。

期间我尝试了修改软路由配置换软路由系统，重新打水晶头，在小黄鱼上租了一台福禄克DSX2-8000来测试我家的所有网线，结果都显示都能通过测试，换过网卡，换过网卡模块，更新过软路由也更新过Windows系统都没什么用（我家的网络是双网关结构一个是主路由爱快另外一个是热备OpenWrt来实现即使有一个网关自动升级了也不影响我上网跟部分对外的服务，网线用的是超六类并在交换机跟网关端做接地）。

在直播的时候有观众问我会不会是外部网络的问题，我一开始不是没想过的，在怀疑软路由的QOS策略的时候就已经想到了，我平常用的是联通的线路切换到电信的线路问题依旧我就尝试过Ping主网关，一直Ping了一个小时发现内网有线延迟时不时跳三十多毫秒我就知道肯定是内网的问题跟联通没关系，前几天我在论坛上看到有人有给我差不多的问题说更新了一下网卡驱动就好了，我本来不是很相信的（我心里想这八成是心理作用吧，网卡驱动影响能有多大），我抱着试一下的态度下了一个驱动精灵更新了一下网卡驱动，更新完之后NMD的还真好了，我再怎么Ping网关延迟都小于1毫秒，傻逼Windows11自动下的网卡驱动还真他妈的有问题的。

不懂就问，为什么之前我那么喜欢她，但从别人那了解到真实的她后，我会有一种失望的落差感。你之所以会产生这种失望的落差感，核心原因在于想象中的她与真实的她出现了巨大偏差。这种偏差源于几个关键心理过程，

1、滤镜效应下的理想化投射。你最初对她的好感叠加了优秀预备党员等标签带来的光环，不自觉的给她加上了滤镜，把自己期待的美好特质，比如热心、体贴、有责任感投射到她身上，甚至主动忽略可能存在的瑕疵，这时候你喜欢的其实是你想象中完美的她，而非真实全貌。

2、信息差导致的认知片面。在与她的互动中，你接触的多是局部信息，比如她的优秀标签，你们有限的交流场景。而从同事那里了解到的她，则是她在工作中更真实、更立体的表现。比如计较分工，不愿互助。这些信息填补了你的认知空白，却与你之前的想象完全相悖，相当于打破了信息茧房。

3、情感投入后的心理失衡。你曾为她付出主动聊天、分享荔枝等心意，这种投入让你潜意识里期待他值得被这样对待，即符合你心中的美好形象。但当发现他的行为敷衍回复、自私，表现与你的期待不匹配时，付出与回报的失衡感会放大失望，甚至产生我看错人的自我怀疑。

4、对一致性的心理期待，人会本能期待一个人的外在标签与内在品质一致，当优秀党员，优秀的标签与计较、冷漠、缺乏同理心的实际表现冲突时，这种割裂感会让人难以接受，仿佛她应该是你认为的这样的信念被推翻，从而产生强烈的落差。简单来说，你不是失望于她不够好，而是失望于她不符合你为她构建的剧本。这种落差不是否定你的眼光，而是提醒你，任何人都有多面性，喜欢一个人时，不妨先允许它是不完美的真实，而非必须符合你的想象。

你该明白有时候沉默是一种答案，她的态度也是答案～

其实你心里早就有答案了对不对就像擦着一张不及格的试卷却反复检查有没有算错分

你说她隔好久才回永远等你主动，这些细节明明都在敲警钟呀喜欢是藏不住的

就像饿了会想吃饭，想念会忍不住点开对话框，她分享幸运时你会心跳加速

但你有没有注意到你给她的加油是带着期待的奔赴，而她的回应更像路过时顺手递的一颗糖，甜一下就没了后续

人有时候会骗自已慢热，但慢热的人会慢慢靠近，而不是让你在原地猜谜呀

你说心有灵犀可真正的灵犀，是她能接住你的情绪单方面解码她的每个标点符号

就像你考试前紧张她的鼓励是礼貌，但如果你难过时她会不会主动问怎么了？这种差别藏着真相呢

你看一段健康双向的喜欢是双方都会不自觉的靠近就像春天的藤蔓会互相缠绕生长而不是一方拼命攀爬另一方却只是安静位立在原地

她隔很久才回复你消息甚至一整天都不主动联系，这已经是很明显的信号

她的生活里，你不是那个会被优先想起，优先分享的人

那些所谓的礼貌性鼓励，就像随手送出的明信片轻飘飘的和你满心期待的厚重回应完全不对等 

你说自己在聊天中找回来了幽默感，可你有没有想过这种高光时刻本应该是相互的自然流动的

如果一段关系里你始终要费力去维持去猜测对方的心意甚至要不断给自已找理由她可能只是慢热

那本质上你是在和自已的幻想谈恋爱而不是和真实的她

第一眼没心动真的很难靠单方面努力改变，感情的奇妙之处就在于有些瞬间的感觉缺失了，再怎么弥补也填不上那个缺口，你反复回顾聊天记录试图从字里行间寻找，她也喜欢你的蛛丝马迹

可那些空白，那些延迟的回复，早就说明了一切，她不会因为你的坚持就突然心动，就像夏天再怎么努力也催不开秋天的枫叶

你不是在刷存在感是太想被看见了，但感动自已的剧本里主角只有你一个人呀！

与其町着她回消息的速度不如看看自己你明明会讲有趣的笑话会认真准备考试这些闪光点不该用来讨好一个没那么在意你的人

放他去当别人故事里的配角吧，你的剧本该换个更亮的主角了，你值得被坚定的选择被满心欢喜的回应

现在的你把太多的精力和情绪都消耗在了一个给不了你同等回馈的人身上，这对你太不公平了及时止损不是认输而是对自已的温柔和负责。

放下这份执着你会发现外面有真正愿意和你双向奔赴认真聆听你主动靠近你的人在等你。

回避型依恋人格回避型依恋人格是依恋类型的一种，主要表现为在亲密关系中对情感亲近有明显抵触，具体特点如下:

1、抗拒情感联结，下意识与伴侣保持距离，比如避免深度谈心，减少肢体接触，甚至在关系升温时产生逃离冲动。

2、过度强调独立，习惯独自处理问题，很少向伴侣表达需求，认为依赖他人会威胁自我独立性，甚至将伴侣的关心视为束缚。

3、习惯理性，压制感性。面对伴侣的情感倾诉时，更倾向于分析对错而非共情，显得冷漠或敷衍，对关系细节敏感，表面对伴侣的言行无所谓，实则对过度亲密的行为如追问行程、表达依赖极度抵触，容易因压力而疏远对方。

4、自我保护的防御机制，否定情感需求。内心可能渴望亲密，但会用独立包装真实感受，甚至在伴侣靠近时产生对方会伤害我的预设。

5、用疏远应对矛盾，遇到冲突时习惯沉默或回避，而非沟通解决，认为不面对就能避免伤害。这种依恋模式通常和童年互动模式与抚养者的情感忽视相关，比如要求孩子懂事别麻烦人，或成长中因表达需求被否定，逐渐形成靠自己才安全的认知。回避型依恋的核心是通过推开他人来保护自己。但健康的关系需要适度靠近，试着放下防御。

其实，被爱并不等于失控呀。如果你总在关系里忍不住后退，别怕，那不是你的错。你筑起的高墙，其实是过去那些依赖会受伤的经历悄悄打起来的。他曾保护过你，只是现在偶尔会挡住阳光。试着慢慢告诉自己，偶尔依赖不是软弱，被人关心也不是束缚。就像冬天里两只互相取暖的刺猬，保持一点距离是本能，但稍微靠近一点也能感受到对方的温度呀。你不必一下子拆掉所有防备，哪怕只是允许自己偶尔说一句我需要你，所以已经很棒了。

如果你是这样的人，别怕那不是你的错，你只是害怕受伤，太想保护自己了偶尔的依赖并不是软弱啊

事情的起因是我换了新手机，然后登录时二次验证发现收不了验证码，看了好多帖子，结果发现去年开始其实大陆手机号就收不了验证码了。我想着我另外一个安卓手机还处于已登录状态，于是就想在设置里取消二次验证，结果好家伙，我自己在登录状态下取消也要接验证码，还是接不了，真是万恶。然后我在 Twitch的官网找文档也发了工单给客服第一次说的是我无法收到验证码请求客服的帮助客服是这样回复的

Hello shimmerls,

I understand that you are not receiving verification code.

We have performed some checks and changes for you, and the SMS reception issues should be resolved now.

Although it should be resolved now, it can sometimes take up to 48 hours to process. If after this time period you're still experiencing issues, please check back in with us!

Thank you,

Twitch Suppor

过了两天之后还是不行，我昨天晚上又开了一个工单这一次直接要求取消掉二次验证，结果根本就没人理，都是机器回复。

Hi shimmerls,

I understand that you would like to change your 2FA phone number.

If you do not have access to your Twitch account please fill out this phone change form from our 2FA provider, Authy.

When filling out the form, make sure you select the country code on the left and enter your number (without the country code) on the right. Do not include spaces in your phone number. 

If you've forgotten your old phone number or lost access to the email address that was registered to your account when you enabled 2FA, please contact Authy Support using this link.

You may need to provide your Authy ID to verify your account. Your Authy ID is: *********

Once the form is completed, you'll get a confirmation email to the email that was on file when 2FA was originally enabled. This may not be the email currently associated with your Twitch account if you have used 2FA in the past. Verifying this email will confirm the change, otherwise no change will be made. The entire process may take several days, and you will also need a replacement number to fully complete the above transfer request.

We recommend that you install the Authy mobile app from https://authy.com/download/ as it doesn't need cellular reception to generate your unique authentication code. Using an authenticator app is especially useful if you need to access your Twitch account whilst you are on holiday abroad or attending a large event, such as a convention, where reception can be unreliable. We also recommend having backups enabled for your authenticator, as this allows you to easily regain access to your account in case you lose your primary authentication device. You can find instructions on our help article Setting up Two-Factor Authentication (2FA).

Best wishes,
Twitch Support

This message was sent to **@****.*** in reference to Case #*********

 6/30/2025 11:39 AM

然后又尝试用Authy验证器，结果发现Authy也用不了大陆手机号，真特么尴尬，直接无解。
于是我回去看twitch给我发的邮件发现可以换绑手机号那么刚好我有一个在挪威留学的朋友，我直接让他给我搞了一个手机号。关键就算有挪威的手机号也不能直接用。因为请Authy官方以人工方式把原来的手机号换成新手机号，因为和关闭二次验证一样，换号也需要原来号码接码，我真的是日了，

于是我就用上面的换号链接填写信息。最后提示我需要2到4个工作日才能换号成功，我心里想还要再等两天那可不行。

我直接到twitch的帮助页面申请换绑手机号，换绑好了之后我去登录Authy然后又有一个坑，用安卓手机的Authy，一进去就说我什么Token不对直接给我退回桌面，这他妈的我手机号都没输，程序就直接报错。然后我又用iPhone试，结果iPhone也不行，说手机不满足最低的安全标准，我是真服了。

折腾了那么久就这结果，于是我到处趴文，Reddit什么的各种论坛全看了还是找不到原因。最后没法又看了下官方文档发现国内的安卓手机系统都经过厂商的魔改，可能没有被识别成安卓，所以就用不了。至于iPhone 你们能想的到原因是因为我没有使用英文做为系统语言，因为最低安全标准的语言是英文。这种问题我在国外论坛查自然是找不到结果，最后系统换成英文后，Authy终于正常使用，我登录了进去之后第一件事是直接把二次验证取消了。

希望可以给其他朋友一个思路。

你们有没有觉得现在国内的很多婚姻观念都很奇怪，结婚的刚需竟然不是很多很多的爱，而是很多很多的钱

而且仔细想想这些观念就像钻石广告一样也就是近二三十年才有的东西，大家现在真的有点因果倒置的意思结婚本来就是两个相爱的人顺其自然达到的一种关系，婚后两个人共同努力共同创造美好生活，但是现在大家的感觉就是每个人都想一步到位找一个能带给自己美好生活的人哪怕没有感情都没关系的可以婚后慢慢培养

还有一个很大的问题我们从小到大都没有接触过正确的婚姻观和爱情观教育导致女生只能从偶像剧里了解男生；男生只能从妈妈身上了解女生，可是偶像剧里那些男生本来就是女编剧臆想出来的，一个男生这辈子也不可能再遇到第二个像妈妈一样无条件照顾你，偏爱你的女生。

这也是为什么我们这一代人谈恋爱这么容易受伤的原因，因为我们对异性的想象和期待本来就是不现实的；是我们臆想出来的。

我觉得不是所有流行的东西都是好的；也不是所有流行的观念都是对的；好的婚姻一定是始于爱情，忠于人品。

这本书的核心是心理治疗大师萨提亚的冰山理论是说每个人都是一座冰山，水面之上是外在的行为，那些惯怒耍脾气劳叻对某些事物的上瘾，这些不过都是表面上最浅层的部分， 而隐藏在水面之下的那些更加深刻的感受情感体验内心期待以及被爱被认可的渴望这些才是生命的重头戏 。

水面之下的这些才是塑造人的行为和性格的根源所以或许就会联想到有关于看见的这个命题。

我们常常说爱，常常把爱挂在嘴边

可是到底爱的真切的是眼前这个活生生有血有肉的人还是只是脑子里刻画出的一个应该效如此的影子

冰山模式是什么呢？

冰山理论是一个隐喻。人就像一座冰山，能被看见的只是表面很少的一部分，就比如行为、事件或者故事，这些就是水平面以上的部分。水平面的那一条线指的是人应对的模式，亦称为"求生存的姿态＂　

而人更大的一部分藏在更深的层次，那是人的内在。人看不见内在，恰如一座冰山只有七分之一露出水面，另外七分之六藏在水面下，分别是：感受、感受的感受、观点、期待、渴望与自我。

冰山水平面下的第一区块就是感受

这个感受指的是最直接的身体感受，冷热兴奋愤怒等，可是很多人又会经过大脑的加工之后

曲解自己最直接的原始的这种感受，比如说有一个孩子摔倒，他会因为膝盖的疼痛哭可是

父母看到会责他说哭什么，不许哭

他们会用对比以及成人的角度去曲解孩子的疼痛，以至于也掐断了感受流通的那种通道，所以慢慢的孩子也会对自己的感受撒谎

自己的声音被父母的声音或是他人的声音盖过而感受不到自己真正的感受，久而久之可能对于什么是疼痛或是其他感受这样的概念都模糊了。

接着是第二层感受的感受

也就是对于刚刚的最直接的感受又产生了一种评价而后生成的一种更新的感受

书里举了一个例子是一个人在葬礼上收到了自己彩票中奖的通知，他在收到通知的那一瞬间感到非常开心而后意识到他身处的这个葬礼的场景不应该出现如此开心的情绪，于是他马上叉产生了一种愧，这个愧疚指的就是感受的感受，似乎是大脑在拿一些社会的标准或是好孩子的规矩来为自己的原始情绪量刑

再往下是观点

可能是一些根深蒂固的观念，或许是来源于过去受过的伤，遭受过的挫折而形成的伤疤，比如说认为达不到要求，等于自己一文不值，对方的沉默等于自己要被抛弃了

然后是期待

这些可能是别人对自己，也可能是自己对自己的具体的要求

比如说到时间了应该关掉电视或是即便对方没有明说自己也应该能够懂得对方的意思，这些期待如果没能被落实或者完成，可能就会让人感受到痛苦，可是往往人会容易分不清这些期待到底是他人要的还是自己真正想要的。

最后潜到了冰山的深处，也就是渴望

这些是爱的最终归宿，人所有的期待、所有的目标和向往被爱、被认可，希望自己活得有意义，活得有价值能够一定程度上为了自已做主，如果达成不了这些，很可能就会觉得生命没有意义，也很难再走向最深层次的自我。

人在成长过程中常会受到环境的伤害有些父母常把"期待"与"渴望"混淆，当孩子达不到父母的期待，父母的言行常让孩子无法满足渴望：感受不到爱，感受不到自己的价值，感受不到被接纳，感受不到自由，感受不到生而为人的意义。

人常常忽略自己的渴望。有的人长久没有价值感没有自由的感觉、没有意义感、不被自己与他人接纳，甚至没有被爱的感觉。

人如果能体验到"渴望" 就能体验到生命力，也能与自己达成深层的理解与联结，所以基于这套冰山理论作者李崇建老师在书里给出了一套沟通心法是不给答案，不解决问题，不讲道理和不问为什么，这些方式看起来可能有一些反常，因为我们习惯的爱都是要给对方出谋划策为对方解决问题，可是这些理智大于情感的沟通方式反倒忽略了水面之下冰山的复杂的其他层次。

很多时候朋友来求助他们心里或许已经有了答案和解法只是想要得到一些情感上的支持而一旦得到了这些或许所有的问题他们完全有能力有想法自己去解决

书里有一个词叫弹奏冰山也就是利用冰山理论去看见与自己沟通的人但弹奏冰山指的并不是摆出一副高高在上的救世主架势去为对方解决问题

而是真切的要对对方保持好奇去探索他的内心去了解他冰山便更深的每一层层次了解的越多看见的这个人的部分也就越多

罗杰斯有一句名言：“如果有人倾听于你，不对你评头论足，不替你担惊受怕，也不想改变你，那会有多美好！＂由此看来，对话的前提是懂得倾听，真正的倾听并且好奇：一个人如何成为现在的样子？

对别人感兴趣，才会懂得好奇。关心一个人，或者对人呈现"某种状态"感兴趣，好奇人怎么生活？怎么成为这的状态？这样的应对有用吗？这样的观点怎么来？

好奇这些，就能让人拥有觉察。无论是阿德勒、罗杰斯或是萨提亚，都指出倾听、关心与好奇是让人活出自己的关键，也是心理治疗的最好方式。

人与人的关系形成了心防，或者不想联结的状态，常因为"彼此关系中的历史”，或者对方与人互动关系的历史”，亦即"过去对方遭遇了什么，使得关系成为如此"。

改变彼此关系，有诸多方式可行，提问的方式也很多，但是面对这样的状态，最简单的方式是表达。专注而稳定地表达爱、表达接纳，渐渐让对方联结。

最关键的就是先管情绪，再管事；先关注感受，然后再想如何解决问题

或许当水面下的那些复杂的泌涌的感受如悲伤、焦虑、恐惧这些通通被看见，被允许被说出来了，那水面上的那些问题自己就松动了。

在生活里我们好像很稀缺那种被完整接纳的感受好像大家都很习惯伪倾听。

什么是伪倾听？

比如说当朋友对自己讲述一些事情的时候对他说你当时就不应该这样想，或这样做，或者他这个人怎么这样，一顶帽子扣过去，又或者是表达自己的一些焦虑的想法比如 这可怎么办呀，完了；或许就是把这样的情绪又抛回给对方，或者是急着改造话没听完解决方式都已经出来了，比如我要是你我就如何做或者你应该如何做

这些都不是倾听

这些或许对于对方来讲都是制造噪音，反倒掩盖了对方想要表达的真正的自己

书里举了一些例子

比如说在儿子打游戏时对着儿子大声责的父亲，在水面上看他的这些行为看起来就像是一个暴君，不由分说的

只要见到孩子有打游戏的这个动作他就冲上去大声斥责可是潜到水面下去看，他在水面之下还有很多不同的感受比如对孩子功课的焦虑对于管不孩子的无力感以及还有一种担忧自己是否能够做好一个父亲的恐惧，而对于被吼的孩子表面上的磨蹭和对父亲的顶嘴在水面之下能够看到是他对于自己的时间有一种想要掌握的渴望

对于爸爸对他表露出的一些斤责他也会产生一些愤怒和对于我自己真的那么差劲吗？那种自我怀疑；两座冰山在水面下相撞击打起的那些表面上的争吵不过是翻腾起的浪花，可是爱，只町着表面的这些翻腾的浪花那无异于是一种鸡同鸭讲

书里还有一对例子

是一对一吵架就会陷入短暂冷战的夫妻，站在妻子的角度来说他是很希望在争吵爆发的时候两个人先冷静一下，冷静10分钟，在这股激烈的情绪过去之后两个人似乎比较容易有更加高效的沟通；可是在这10分钟的双方冷静的时间里丈夫就会一直追问说你怎么了为什么不说话，妻子会对丈夫的行为感觉非常无理取闹，可是探到冰山之下去看丈夫小时候就在有类似冷战的环境里长大妻子的短暂的沉默对他来讲并不是什么想要彼此先平静一下的信号，而是他感受到了自己似乎又要被抛弃直接引爆了内心童年时期就隐藏着的恐惧

如果不通过冰山去层层剥茧了解两个人的内心那或许妻子会一直认为丈夫是这样无理取闹的人，而丈夫就会认为妻子就是一个喜欢冷暴力的人两个人彼此之间是有爱的如果不去看见对方这一份爱就会被这种看不见所击沉

所以真正的看见是爱的深潜，不仅仅是对表面上的那些表层行为指手画脚，评头论足，而是潜进对方的冰山深处去看看他此刻真正的感受是什么？是愤怒，还是被愤怒掩盖了的创伤或是恐惧，还有支撑他行为的观点是什么？

他心里有怎样的期待？以及最深层的那个共通的渴望是什么？

爱 如果只是在水面上指指点点，修修补补那不是爱是自我感动是一种控制欲真正的爱是要带着勇气和好奇去潜进对方也潜进自己内心可能有些冰冷的深海去看见水面下的带着伤的也最真实的那个灵魂看见他的恐惧、看见她的俪强、看见孩子想要获得的掌控感、看见父母心底深处的一种无力、看到伴侣沉默背后的旧伤痕只有看见才能够理解，而只有理解了才有可能建立深层的联结。

所以下一次在说出我爱你这三个字的时候可以先们心自问一下到底有没有真正的看见眼前这个人看见的部分又有多少？到底是看见了那个庞大的水下的世界还是仅仅只看到了水面上的，非常有限的一角

爱的程度有多深或许也取决于看见的有多深

引信

今天是520不过是365天里最平凡的一天日历上的数字不会自动发光花店里的玫瑰价格如常就连拂面的晚风也依然带着往日的温柔，可仔细瞧熊街角有人手捧鲜花静静守候，备忘录里藏着没说出口的心动还有人对着镜子反复练习微笑原来生活的温度都是我们用真心慢慢悟热的。

恋爱中的人

恋爱中的人们不妨放下仪式感的包袱，订不到浪漫的烛光晚餐又如何，礼物不过贵重又何妨，爱情最美的模样，往往藏在深夜为对方留的那盏灯里，藏在争吵后主动低头的那句我错了里，藏在千万次默契对视的瞬间里记得转身对身边人说声感谢，谢谢（TA）接住你的脆弱，也陪你绽放光芒。

单身的你

更不必在今天感到落寞，你或许正享受着独属于一个人的自由把日子过成喜欢的模样或许仍在等待那个对的人，在相遇前默默成长为更好的自已，其实你看拨通父母的电话崂崂家常，约上老友酬畅淋漓的吃顿火锅甚至只是给自已买一束盛放的鲜花都是爱意的流尚，爱从来不是爱情的专属你，对世界的善意，对梦想的执着，同样熠熠生辉。

清醒提醒

520从来不是一道非黑即白的选择题不必困在《我爱你》的标准答案里，它应该更像生活寄给每个人的情书温柔提醒我们无论此刻是一人独行还是有人相伴，都要记得做自已的光用力拥抱这个斑斓世界，认真丈量脚下每一寸风景更要毫无保留的宠爱那个独一无二的自己，毕竟人生路上的每一次擦肩与相逢，都是命运赠予我们的成长礼，让我们在跌跌撞撞中，学会以最从容的姿态，迎接爱与被爱的勇气，即使今天不过是平凡日子里的一天也请继续做那个闪闪发光的自已，把每一天都过成值得珍藏的浪漫。

其实这段时间，我一直在想怎么和你说清楚或许是我没把握好聊天的边界感那些嗯嗯，好的，只是我习惯性回复对很多朋友都是如此，并没有特别的含义。

你说我上进，其实这只是我对自己的基本要求，换作其他人做到这些，你也会觉得吸引吧，最初你被这份上进心所打动，可仔细想想这更像你对优秀特质的欣赏，而非对我这个人的喜欢，那天你说“看到你的消息就开心”我盯着屏幕犹豫了很久，不是故意冷淡而是不知道该怎么回应越界的期待，你总说等我回复时会焦虑，其实我们对聊天的需求从来都不一样，你渴望高频的情绪互动，期待我主动分享生活细节

可我天生不是擅长热烈回应的人，即便对好朋友也很少倾诉心事，这种错位不是你的错，是我们在相处模式上天生不合拍

断联这些天我猜你一定很难受，但你注意到我的声音不算好听，长的不算好看，其实是潜意识在提醒你那些让你上头的瞬间更多是聊天频率堆积出的熟悉感而非真正的心动。

你对我的依赖本质是对热烈回应的需求而我没办法成为那个和你双向奔赴的人，我不想消耗你的热情，不想让你在期待、失望的循环里自我怀疑。

你值得遇到一个让你想起时眼睛发亮的人而不是在他为什么回复慢的猜疑里患得患失。

清醒提醒

你跟他的高频聊天带来的上头本质是大脑对稳定回应的依赖不是真正的喜欢，他的礼貌回复是社交常态别误读为特殊信号

你列举的吸引点 上进 优秀是抽象标签，而非具体的

他这个人连声音长相都无法打动你的细节早已暴露了好感的脆弱性，他的冷淡不是故意敷衍而是明确的边界感，他没有义务回应你的情感需求

你的焦虑源于期待他成为理想中的回应者，而非真正了解他，在主动聊天等待回复失望的循环里越陷越深，只会让你忽略真正值得奔赴的关系，真正的喜欢是双向奔赴，不是单方面在他回不回消息里猜疑

最后想对你说感情里最遗憾的不是错过而是为了一个不对等的人耽误了自己遇见对的人他的冷淡不是因为你不够好，只是你们的情感频率不在同一个频道上，承认不合适需要勇气，但这恰恰是成熟的开始

现在的你就像从一场热闹却略感局促的聚会中提前离场或许有点孤单，但走出大门的那一刻会发现属于你的星空，一直都在你头顶上发亮呀。

钉钉旧版本安装程序

https://dtapp-pub.dingtalk.com/dingtalk-desktop/win_installer/Release/DingTalk_v6.0.26.9039963.exe

先去官网安装最新版本的钉钉 https://www.dingtalk.com/

打开钉钉的安装目录

在这个目录DingDing\main\current\configurations里找到staticconfig.xml 文件复制出来，然后就可以卸载掉最新版本的钉钉了，然后下载上面的旧版本安装程序，安装好了之后在同样的目录把旧版本的staticconfig.xml 文件也复制出来，把刚才新版本的staticconfig.xml 文件替换进去，现在打开钉钉进行登录就不会提示是旧版本了，登录时选上自动登录，但是登录进去之后聊天功能变成乱码这个先不管，然后先进设置关闭自动更新然后关闭钉钉，将刚刚备份的旧版本文件替换回去，在打开钉钉会发现聊天功能恢复，（因为前面登录的时候点上了自动登录，所以在登录就会无视版本自动登录，因为禁止了自动更新所以不会自己更新可以一直使用）

利用原理

将新版本的信息替换旧版本信息，让程序认为已经是新版本，但因为新旧不一样所以只能登录但是无法聊天，然后因为点了自动登录，所以在将旧版本文件替换回来就可以自动登录，禁止自动更新防止钉钉自动更新。

注意：钉钉不要改密码，不要更换账号登录，不然自动登录会自己关掉，然后还想用旧版本登录只能重新替换文件

一、在 NPM 上注册一个账号并且验证完账号邮箱。

二、在项目文件夹中打开CMD或终端

三、在使用登录NPM并且按提示依次输入用户名 密码 注册邮箱

npm login
Username:（你的NPM用户名）
Password:
Email: (this IS public)（你的邮箱地址）
Logged in as （你的NPM用户名）on https://registry.npmjs.org/

提示登录成功

四、创建NPM包

npm init
package name:（你的想要创建的包名）
version: (1.0.0)（版本号）
license: (ISC) ISC

五、发布NPM包

npm publish

等等提示发布成功就可以了

这段时间很多中小型网站都山西太原联通的IP刷了CDN的流量；根据经验和网友们的分析，攻击应该是PCDN用户为了均衡流量人为刷下载流量导致的。

攻击特征：针对小型博客/网站等的某些图片和视频等静态资源，选择其中比较大的一个资源进行刷量。

本站采取临时措施将所有静态资源上传到 JSDelivr CDN做URL重写，清理了一次CDN缓存，删除服务器内的静态资源。IP访问限频调整成30 QPS ，设置UA白名单，下行限速：100KB/s，屏蔽有关IP

7月6号 晚上7点到11点 首次对本站CDN进行攻击由于一开始我给本站的下行限速设置在6M对我的CDN流量刷了9G此时我还不知道

直到12号的晚上8点当时我正在跟朋友打游戏，收到腾讯云同时发的邮件及短信CDN流量低于告警阈值百分之30 我就想着我不是才买的流量包吗？我赶紧打开腾讯云看了实时监控发现已经连续被刷很多天了，我第一时间调整了下行限速到：100KB/s，查看了IP进行封禁本以为事情就这么过了。

过了几天17号晚上换了一个香港的IP又刷了10G一样的还是晚上7点到11点腾讯云再次提醒CDN流量低于告警阈值百分之20 这一次我将静态资源上传到JSDelivr CDN设置URL重写，删除服务器上的资源，设置了UA白名单；到了第二天上午打开腾讯云一看昨天晚上七万多条514的报错。流量包跟余额也正常了，此事应该能告一段落了？

封禁的IP

156.224.24.203
221.205.168.0/23
60.221.231.0/24
211.90.146.0/24
122.195.22.0/24
118.81.184.0/23
124.163.207.0/24
124.163.208.0/24
183.185.14.0/24
36.35.38.0/24
60.221.195.0/24
60.220.182.0/24
61.160.233.0/24
153.101.65.0/24
153.101.51.0/24
221.6.171.0/24
61.147.95.0/24
36.151.55.0/24
114.230.220.0/24
49.86.47.0/24
153.99.251.0/24

以下是其他受攻击网友的文章

公告 - 多吉云 (dogecloud.com)

记一次 CDN 流量攻击事件 | 太傅博客 (taifua.com)

小心，近期国内云CDN用户遭受到恶意刷流量！（附赠IP地址段黑名单） - 明月登楼的博客 (imydl.com)

每天晚上 20~23 时准点被山西联通 IP 刷流量现象的分析和猜测 - V2EX

遇到脚本小子（小丑）的 CC 攻击，大家有什么好的建议？ - V2EX

公司的阿里云 CDN 每晚都在被偷偷刷量 - V2EX

CDN 被刷流量 异常流量 - LeaRM

本文持续更新，所有的菜都经过我家小馋猫女友亲自尝试过并且认可后才放上来，多为南方清淡菜系。后续菜品多起来之后可以通过按 Control+F 来搜索你想看的菜品

免责声明：

1. 本文章凉茶章节内容均不适用于孕妇，因食用本菜谱导致的任何问题与本人无关，家中有孕妇的请谨慎食用，建议在有中医、二甲级公立医院健康管理中心医生、月子中心或营养师的监督下食用。

2. 凉茶章节内容均为两人食用的量且女生没有怀孕。

不会焯水？

肉类冷水下锅，中火烧至70-80度，也就是锅边开始冒泡，锅内冒热气。转小火，搁楞搁楞，捞出来温水冲洗。

肉类焯水浮沫都粘在肉上有两种原因，一是水少了，水要完全没过肉；二用中火让水沸腾，等血沫彻底凝固再捞出来用温水冲洗。

生菜焯水短了容易变黄，解决方法：热水下锅10秒左右即可，蔬菜焯水放点食用油可以保持绿色鲜嫩。

冷水下锅：；大块的肉类、内脏食物还有根茎类蔬菜（竹笋土豆山药胡萝卜）

热水下锅：叶菜和海鲜；蔬菜焯水时一般旺火宽水，火大水多快进快出立即过凉

如果要加盐尽量在水开后加，不然锅子容易生锈或者又斑点痕迹

空气炸锅

奥尔良烤翅：

烤翅加水泡一个小时，泡出血水，可以减少腥味，将鸡翅洗净后，两面滑两刀，加点料酒、生抽、少许姜丝、奥尔良腌料，抓匀腌制30分钟，空气炸锅180度预热一下（可以预热也可以不预热），空气炸锅底部刷一点油腌好的鸡翅放在空气炸锅里（如果用的是空气炸锅一次性纸盘或者锡纸盘直接刷盘上），180度先烤10分钟然后刷蜂蜜翻面再烤5分钟，喜欢吃焦一点的小伙伴可以再多烤几分钟哦！

炸牛奶：

400ml牛奶，加入50g玉米淀粉，30g白砂糖，小火搅拌至粘稠状，倒入长方形模具放入冰箱冷藏2小时，脱膜切条，再裹上玉米淀粉、蛋液、面包糠，放入空气炸锅180度10分钟。

蒸

清蒸排骨：

排骨切段洗干净加葱姜泡水半个小时到一个小时可以去除，泡完之后清干净放入油、盐、糖、玉米淀粉，少量胡椒粉没有可以不放抓均，腌制15分钟；锅中加水大火煮开，把排骨放进锅后转中火蒸20分钟。（另外可以拓展出香竽蒸排骨、南瓜蒸排骨）

清蒸鲈鱼：

鲈鱼处理好内脏后冲洗一下，用刀在鱼身划上几刀盘中上先放上葱姜丝垫底（可去腥），放入鱼，再铺上几片姜，水开放入鱼蒸8～10分钟，关火再焖5分钟。蒸好的鱼去掉葱姜，倒掉盘里的汤汁，重新放点葱姜丝，加入2勺蒸鱼豉油，油烧热淋上去。（有些朋友鱼不管怎么处理都有腥味有个小技巧清理完内脏后用刀从鱼头向鱼尾刮三下这一步可以去掉鱼身上的粘液这样子后面再放葱姜就不会腥了这样子做有一个不会的点就是在蒸的过程中鱼皮会破掉除了不好看以外没其他问题，网上也有用生粉的那个我觉得太麻烦了如果你想拍照发朋友圈的话可以用生粉）

盐焗鸡：

鸡腿洗干净热水烫30秒左右(这一步可利把皮烫紧实更好吃)，餐巾纸/厨房纸擦干水分加20g盐焗粉、1勺油，抓匀腌制30分钟，水开上锅蒸熟。

炒

猪油炒菜有个好处是，猪油本身就是熟的，所以可以低油温下菜，适合做饭新手用，避免高温油下菜炸得到处是油，另一方面也适合一些容易焦糊的食材，低温油下菜再慢慢提高温度加热烹饪，能更好把握火候。

清炒土豆丝：

土豆跟青椒切丝，清洗掉多余的淀粉，热锅热油，下青椒香后下土豆丝加入少许盐，糖提鲜，大火翻炒均匀

辣椒炒肉：

五花肉洗干净后切片（猪肉要顺着肉的纹路切，这样子肉就不会柴也就不需要放生粉，牛肉逆着切，把纹路切断，才能咬动），青椒切三角或切丝，小米椒切圈备用（小米辣喜欢吃就放也可以不放，放的话跟辣椒一起放进去就好了）

五花肉肥肉比较多的并且用的是铁锅可以不放油，热锅放入五花肉翻炒一下慢慢的就有猪油出来了看到有油出来了之后立马倒料酒，翻炒到七分熟放入辣椒翻炒，根据口味放入老抽、生抽，鸡精或味精翻炒均匀。（如果是瘦肉比较多就先放一点油热油下锅）

如果是涂层锅先放一点油，油热下锅，然后跟上面的步骤一样就好了。（如果你不放油你多炒几次之后，你的什么不粘锅就没了不字了只剩下粘锅，你就炒吧一炒一个不啧声）

煮

猪脚姜

猪脚 1 只、生姜 1 斤、甜醋 2 瓶（建议使用八珍甜醋或者致美斋）、鸡蛋若干个、红糖 1 小块

处理食材：生姜去皮，放阴凉处自然风干后，用刀背拍扁。锅中不放油，将生姜煸炒至表面无水分盛出。猪脚洗净，冷水入锅焯水，捞出冲冷水，沥干水分后放入锅里炒干水分。鸡蛋冷水入锅，煮约 8 分钟后浸入冷水，剥去蛋壳备用。

先说注意事项：不要加水，不要加水，不要加水，不要加水，不要加水，一滴水都不需要加

取一砂锅，加入生姜、甜醋、红糖、猪脚、鸡蛋大火煮开后小火煮50分钟左右。静置到第二天加热煮开即可食用。（后面这个不是必要的可以立刻吃，放一天之后会更入味）

适用人群 ：适合产后女性、气血虚弱者、体质虚寒人群，以及容易手脚冰冷、畏寒、消化不良的人。此外，普通人群在秋冬季节也可适量食用，以培补阴阳气血。但湿热体质、胃酸过多者不宜多吃

腊肠饭：

广式腊肠切片，加入2勺酱油、1勺白砂糖、半勺鸡精，搅拌均匀备用，等饭煮到表面看不到水的时候放入腊肠直到饭熟。再闷个五分钟到十分钟即可。

汤

肉类焯水口诀:冷水汤，热水肉

首先食材新鲜为前提，冷水下锅，慢温渗透会让肉类食材内部的血水与骨髓渗出融入高汤，撇去第一道赃沫之后，就可以放心煲汤，汤水会更加浓厚，所以说冷水煲汤，但是肉类内部精华流逝，这样的肉是柴化的，热水肉是因为高温快速使肉类表部熟化，锁住肉类内部血红蛋白与骨髓等，所包含的油脂与肉肌结合度高，所以口感丰富糯化，汁水丰富。

广东省汤：

猪排骨洗干净剁成小块；胡萝卜去皮切滚刀块；甜玉米**(注意是甜玉米不是糯玉米不要买错了**)洗净切段。将猪排骨放入冷水中焯水，去除血沫和杂质后捞出用清水冲洗干净。将焯好水的猪排骨放入锅中，加入胡萝卜和玉米，加入足够的清水，大火烧开后转小火慢炖。炖约一个半小时后，根据个人口味，加盐调味出锅。

鸽子汤

鸽子，当归，黄芪，党参，红枣，枸杞，桂圆，麦冬把材料洗净，放入炖锅（枸杞除外）煮2-2.5小时调味即可。枸杞关火前10分钟放入

普通乌鸡汤同理

猪蹄排骨汤

猪蹄、排骨、姜、葱、红枣、枸杞、料酒

猪蹄、排骨洗净切块，姜切片，葱切段。水煮沸后加入猪蹄、排骨，撇去浮沫。加入其它材料

小火炖1-2小时至烂。加盐调味，再炖10分钟即可

当归阿胶乌鸡汤：

乌鸡切块洗干净，当归、桂圆、麦冬、黄芪、阿胶、红枣、枸杞、乌鸡、姜片也一起洗干净跟鸡一起放入汤

关于要不要焯水这个问题，焯水的目的就是去腥味，如果你买的是现杀的那么可以不焯，如果是超市里冷冻的建议焯水，

焯水的话冷水下锅，煮开了之后再煮两分钟左右，捞出来洗干净放入汤锅中加入其他材料一起煮就好了。

阿胶糕（sumuu版）

1. 黄酒500ml
2. 东阿阿胶500g
3. 冰糖50g
4. 核桃仁去皮250g
5. 红枣250g去核
6. 枸杞150g
7. 黑芝麻250g

此配方成品大概1.5kg切片大概70片左右

阿胶糕

准备食材

1. 黄酒500ml（黄酒的量是阿胶的两倍如果你是125g的阿胶就使用250ml的黄酒）
2. 阿胶250g
3. 冰糖150g（不喜欢太甜可以少放）
4. 核桃仁250g
5. 红枣250g去核
6. 枸杞150g
7. 黑芝麻250g（如果是生的可以提前在锅里炒熟）

制作过程

1. 把阿胶敲碎用黄酒泡48小时
2. 泡好的阿胶加黄酒一起倒锅里中火熬（一定不要用大火）熬到起泡泡后放冰糖，然后小火慢慢熬，熬到可以挂旗就可以了
3. 关火依次加入核桃、红枣、枸杞、黑芝麻每放一样都是搅拌开再放下一个
4. 提前准备好容器（托盘或者大一些的饭盒长方形的）下面放一张油纸，然后倒入容器里 再铺上一张油纸用平底的工具压实，放进冰箱放凉定型，第二天就可以切片了，有真空机的话可以真空机封口。

凉茶

清热去湿：

夏枯草干 -10g

木棉花干 -20g

茯苓片干 -20g

粉葛根 -20

甘草 -8g

菊花凉茶 -20g

薏米 -20g（怀孕的女生不能放这个，怀孕期间吃薏米可能会引发腹泻、流产等情况，不要存在侥幸心理，健康最重要）

Uptime Kuma 是一个由 Louis Lam 开发的现代、美观且易用的网站监控系统。它是一款开源项目，提供实时监控、故障通知和状态页面，确保您的在线服务始终处于最佳状态。

该项目的GitHub地址：https://github.com/louislam/uptime-kuma

主要特性如下:

• 可监控 HTTP(s) / TCP / Ping / DNS 等网络•支持 Webhook,邮件多种通知方式，支持简体中文, 支持 Docker 部署。

搭建

• 先创建数据存放目录

mkdir uptime-kuma
cd uptime-kuma/

• 编写 docker-compose.yaml 文件

version: '3.7'
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1.23.13
    container_name: uptime-kuma
    volumes:
      - ./data:/app/data
    ports:
      - 3001:3001
    restart: unless-stopped

保存之后直接 docker compose up -d 运行

浏览器输入http://[IP]:3001就可以看到初始化界面了，输入账户密码完成初始化之后就能进入控制台。

我们点击左上角的 添加控制项 ；监控类型选择HTTP(s)-关键字，名称输入友链的站名，URL输入对方的友链页面的URL；关键字可以是你网站的域名也可以是你网站的名字，心跳间隔我这里设置的是 86400秒 然后保存，程序就会每天都检测一次对方的友链状态以及Blog是否可以访问了。

前言

在 恩山论坛 上有很多用户编译好的现成固件，自己编译固件最大的优势是自定义的添加插件或者其他的特殊需求，强烈建议没有特别需求的用户还是直接选用现成的固件就好。编译固件也是一种乐趣，整个过程大约1-2小时左右如果是单线程大概在5小时左右，需要耐心等待。

环境及要求

1. 系统版本：Debian 11 或者 Ubuntu LTS

2. 最好是境外主机或者能够访问国际网络，大陆直连网络环境编译基本上不会成功，配置推荐 2H4G 以上

安装编译依赖

# 升级
sudo apt update -y
sudo apt full-upgrade -y

# 安装依赖
sudo apt install -y ack antlr3 asciidoc autoconf automake autopoint binutils bison build-essential bzip2 ccache cmake cpio curl device-tree-compiler fastjar flex gawk gettext gcc-multilib g++-multilib git gperf haveged help2man intltool libc6-dev-i386 libelf-dev libfuse-dev libglib2.0-dev libgmp3-dev libltdl-dev libmpc-dev libmpfr-dev libncurses5-dev libncursesw5-dev libpython3-dev libreadline-dev libssl-dev libtool lrzsz mkisofs msmtp ninja-build p7zip p7zip-full patch pkgconf python2.7 python3 python3-pyelftools python3-setuptools qemu-utils rsync scons squashfs-tools subversion swig texinfo uglifyjs upx-ucl unzip vim wget xmlto xxd zlib1g-dev

#清理
sudo apt autoremove --purge
sudo apt clean

创建编译账户并下载源码

useradd -m openwrt  # 新建一个名为 openwrt 的用户
 
# 修改用户默认的 Shell
apt install -y sudo
usermod -s /bin/bash openwrt
 
# 切换用户
su openwrt
cd ~

需要创建账户是因为我们不能直接使用root账户编译，会报错；如果你坚持使用root账户编译也不是不行，但是必须设置下面这个环境变量。这个环境变量设置好了之后只在当前的会话中生效。这个环境变量只需要在编译前执行即可。

export FORCE_UNSAFE_CONFIGURE=1

下载源码

git clone https://github.com/coolsnowwolf/lede
cd lede
./scripts/feeds update -a
./scripts/feeds install -a
make menuconfig

添加软件源，L大源码里默认有四个软件源里面包含了大部分常用插件，如果要添加其他没有的插件则需要自行添加软件源至 feeds.conf.default 文件，当然也可以单独添加某个插件

sed -i '1i src-git kenzo https://github.com/kenzok8/openwrt-packages' feeds.conf.default
sed -i '2i src-git small https://github.com/kenzok8/small' feeds.conf.default

更新并安装插件

git pull
./scripts/feeds update -a
./scripts/feeds install -a
make menuconfig

可选操作

# 修改默认IP为 10.1.1.2
sed -i 's/192.168.1.1/10.1.1.2/g' package/base-files/files/bin/config_generate
 
# 修改默认主机名
sed -i '/uci commit system/i\uci set system.@system[0].hostname='Soft_Router'' package/lean/default-settings/files/zzz-default-settings
 
# 加入编译者信息
sed -i "s/OpenWrt /Kinoko build $(TZ=UTC-8 date "+%Y.%m.%d") @ OpenWrt /g" package/lean/default-settings/files/zzz-default-settings
 
# 修改默认主题
sed -i "s/luci-theme-bootstrap/luci-theme-argon/g" feeds/luci/collections/luci/Makefile

下载 dl 库，编译固件 （-j 后面是线程数，第一次编译推荐用单线程）

# 预下载编译所需的软件包
make download -j8
# 检查文件完整性
find dl -size -1024c -exec ls -l {} \;
# 检查文件完整性命令可以列出下载不完整的文件，小于1k的文件属于下载不完整，如果存在则用下面的命令删除，然后重新下载编译所需的软件包，再次检查
# 确认所有文件完整可大大提高编译成功率，避免浪费时间
find dl -size -1024c -exec rm -f {} \;

最后编译固件，编译完成后输出路径是 bin/targets，默认密码是 password

# 编译固件（-j 后面是线程数，首次编译推荐用单线程）
make V=s -j1

二次编译

1. 拉取最新 OpenWrt 源码和更新 feeds 源中的软件包源码

cd lede
git pull
./scripts/feeds update -a
./scripts/feeds install -a

2. 清除旧的编译产物和目录（可选）

make clean
# 源码有大规模更新或者内核更新后执行，以保证编译质量
# 此操作会删除 /bin 和 /build_dir 目录中的文件
 
make dirclean
# 更换架构编译前必须执行
# 此操作会删除 /bin 和 /build_dir 目录的中的文件（make clean），以及 /staging_dir、/toolchain、/tmp 和 /logs 中的文件

3. 同首次编译，多线程编译失败后自动进入单线程编译，失败则输出详细日志

make defconfig
make download -j8
find dl -size -1024c -exec ls -l {} \;
make -j$(nproc) || make -j1 || make -j1 V=s
 
# 如果需要重新配置
rm -rf ./tmp && rm -rf .config # 清除临时文件和编译配置文件
make menuconfig
make download -j8
find dl -size -1024c -exec ls -l {} \;
make -j$(nproc) || make -j1 || make -j1 V=s

想要解锁网易云的灰色歌曲目前有两个比较可行的方法

1. 在软路由或服务器上部署如 luci-app-unblockmusic 的服务，然后软件上设置相应的代理。

2. 在本地设备上部署如 UnblockNeteaseMusic 的服务，然后软件上设置相应的代理。

本文介绍使用一款插件：BetterNCM 就可以解锁灰色的歌曲也可以帮助我们美化一下网易云音乐的界面

我们可以直接访问插件的网站或GitHub项目的 releases 下载

• 插件网站：https://microblock.cc/betterncm

• GitHub：https://github.com/MicroCBer/BetterNCM

下载完成之后（关闭网易云音乐的情况下）打开安装包会自动识别你的网易云版本直接点安装就好了，安装完之后打开网易云。

在右上角找到这个图标点击即可进入插件列表，第一次进入的时候可能会出现页面空白的情况只需要关闭并重新打开网易云即可。我们先找到 RevivedSource 插件安装，安装完成之后才能看到解锁灰色歌曲的插件 RevivedUnblockInstaller

安装好插件之后左边找到插件选择任意一个版本安装即可。使用的音源如果你有科学上网的能力可以选择使用YouTube的音源。如果没有使用第三方网易云的也可以。

这里需要注意的是部分插件不支持 3.x 以上的版本，你可以在目录里找到一个降级到2.10的插件

• 漏洞编号：QVD-2024-18126,CVE-2024-32002

• 影响范围：Windows 和 MacOS

• 受影响的版本

建议大家赶紧去敲一下 git --version 看看自己的版本在不在上面。

攻击者只需要准备一个Git项目然后引导你去克隆它你的电脑就会自动执行攻击代码就比如下面这个GitHub上的项目；你只要执行 git clone --recursive git@github.com:amalmurali47/git_rce.git 不出意外的话你的电脑就会跳出计算器

amalmurali47/git_rce: Exploit PoC for CVE-2024-32002 (github.com)

近期我自己基于 AdguardHome 搭建了一套加密DNS服务来屏蔽一些国内APP的开屏广告

在我设置完成AdGuard的https之后导出mobileconfig描述文件安装到平板上发现是未签名的状态

去搜了一下发现可以使用域名的证书进行签名

教程开始

需要的东西

1. SSL证书验证（跟https一样）使用Nginx或者Apache的格式都没问题

2. 未签名的mobileconfig文件

3. 如果你的是 Windows 系统你还需要安装Git 工具

域名证书可以在阿里云/腾讯云等云服务厂商免费购买

这里我们下载腾讯云的Apache，解压出来会得到四个文件

csr的文件是不需要的可以删掉然后

key的改成=server.key （你的私钥）

网站的SSL证书.crt的改成=server.crt （你的服务器SSL证书）

bundle.crt的改成=ca-bundle.crt （你的根证书链）

未签名的mobileconfig的改成=company.mobileconfig （你的描述文件）

把四个文件放Mac的一个目录内。

我这个电脑没有安装Git工具并且还没有安装科学上网工具我就上传到liunx的服务器上然后文件夹内使用以下命令

openssl smime -sign -in company.mobileconfig -out signed.mobileconfig -signer server.crt -inkey server.key -certfile ca-bundle.crt -outform der -nodetach

命令运行完之后，会在目录里面生成一个已签名的signed.mobileconfig。之后导入到苹果的设备大功告成。

已验证签名：

本文转载自：自搭建全平台私有密码库 bitwarden & Vaultwarden - OttoLi 的胡言乱语

密码管理之痛

相信大家都有一个困扰，就是各种软件、网站的密码管理问题。很多人都是全靠大脑记忆，估计下面列举的痛点或多或少都有一些。

• 全都用相同的密码，感觉不够安全
• 全都用不同的密码，记忆难度过大
• 各平台的密码长度、复杂度要求不一样
• 有些账号需要定期重置密码，加重记忆负担

那么就需要一定的密码管理策略来解决这些痛点。针对这个问题，我也找到了这么几种方案：

综合来看，首先前四种方案都有较为明显的短板，不适合作为长期使用的密码管理方案。

在后三种专业密码管理软件中，首先安全性都能够得到不错的保证，差别主要体现在可靠度、便利性和成本之间的取舍。

• 选择纯本地，相当于为低成本舍弃可靠度和便利性
• 选择上云，相当于以高成本换取最佳体验
• 而选择私有云，在有云服务器或 nas 的情况下，则可以 0 成本获得最佳体验

本文介绍的私有化密码管理方案将基于开源项目 bit­war­den/Vault­war­den

bit­war­den 是开源的专业密码管理软件，是目前最为常用的密码管理软件之一，主要特点有：

• Windows、Mac、Linux、Android、iOS 全平台覆盖
• 支持 Chrome、Edge、Safari、Firefox 等主流浏览器插件
• 支持 密码、文本、信息表 甚至 附件 的加密保管
• 支持自动填写网页、app 账号密码
• 支持文件加密分享，方便地通过 bitwarden send 分享隐私文件、照片等
• 支持生成两步验证器，为每个密码设置 TOTP 动态口令
• 支持团队密码库，可在团队成员中共享团队密码
• 支持密码检测报告，检测密码库中的重复密码、弱密码、已被泄露的密码等
• 代码开源，支持自搭建，将数据全部掌握在自己手中

在安全性方面，bit­war­den 的原理是使用一个足够复杂的 主密码 来管理其他所有的密码，采用 AES-256 位加密、加盐哈希和 PBKDF2 SHA-256 来保证所有信息的安全。安全性可以这么说，只要你自己不主动把主密码泄露，目前地球上没有能暴力破解的计算机。bitwarden 官网有比较详细的介绍，它会定期进行第三方安全审计，通过了 GDPR、SOC 2、HIPAA、Pri­vacy Shield 和 CCPA 等认证。

主密码无法通过任何方式恢复，如果忘记密码最多只能通过邮件获取你预先设置的密码提示，如果依然无法想起主密码，就会失去所有数据。

Bitwarden也提供了服务端用于自行部署。不过官方服务端性能要求高，所以我使用了用rust编写的非官方服务端vaultwarden(原名bitwarden_rs)。

在使用bitwarden之前，窝总共有四五个密码。最最开始所有账号用的都是同一个密码，后来害怕密码泄露，又想了三四个密码，小网站/小APP使用最简单的密码，即使泄露也无伤大雅，比较重要的账户使用中等复杂的密码，重要的账号/涉及支付的账号使用最复杂的密码。

但是这样还是会有一些小问题，比如1. 一些小网站就要求大小写字母加符号。而有一些APP竟然不允许密码中包含符号。。。绝了 2. 有时候我也不知道某个账号用的是哪个密码，只好所有密码都试一遍。3. 有时候我记不住账号(┬┬﹏┬┬)，因为我有多个邮箱和用户名。

所以我开始使用密码管理器，如果你没有自己的服务器，域名，和比较富裕的时间，我建议使用官方服务，官方免费服务足够个人使用（需要有一定科学上网能力，来接收Google reCAPTCHA）。

Bitwarden提供优秀的自动填充服务,并且可以利用系统的生物识别(指纹,人脸等)进行认证。

同时Bitwarden不止可以用来存储密码，还可以存储文件/文本/银行卡/个人信息。并且提供安全分享功能（seed）。

搭建教程

需要有一台vps，一个域名，如果服务器位于国内则需备案。
我使用的是阿里云1h 2g 5m

(一) 安装Docker和Caddy

1. 安装必要软件

sudo apt update
sudo apt install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

2.添加官方密钥

curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

3. 添加仓库

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

4. 安装Docker

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

5. 安装Caddy

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo tee /etc/apt/trusted.gpg.d/caddy-stable.asc
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy

(二) 部署Vaultwarden

1. 拉取镜像

docker pull vaultwarden/server

2. 启动容器

docker run -d --name vaultwarden -v /vw-data/:/data/ -p 8080:80 vaultwarden/server:latest

这将创建一个名字叫vaultwarden,将容器的/data/目录映射到机器的/vm-data/目录,将容器的80端口映射到机器的8080端口,使用的镜像为vaultwarden/server:latest.

3. 配置Caddy

mkdir /etc/caddy
touch /etc/caddy/Caddyfile
vi /etc/caddy/Caddyfile

按i进入编辑模式,输入

password.example.com {
    reverse_proxy localhost:8080
}

之后输 sudo systemctl reload caddy重启Caddy。
去DNS服务商那里把域名解析到vps,
浏览器访问password.example.com,出现bitwarden的界面就ok.入

4. 注册

点击创建账号,填写电子邮件,设置主密码.
主密码一定不能太简单.
只有知道主密码才能访问密码库,即使别人盗取了你的数据库,在不知道你主密码的情况下依然无法访问你的密码库,所以主密码一定要设置复杂一点.

(三) 设置Vaultwarden

1. 禁止新用户注册并开启WebSocket

为了防止他人注册,需要禁止新用户注册.

docker rm vaultwarden
docker run -d --name vaultwarden \
  -e SIGNUPS_ALLOWED=false \
  -e WEBSOCKET_ENABLED=true \
  -v /vw-data/:/data/ \
  -p 8081:80 \
  -p 30122:3012 \
  vaultwarden/server:latest

之后去修改 Caddyfile, 添加

reverse_proxy localhost:30122

(四) 获取Bitwarden应用

访问 https://bitwarden.com/download/ 获取各平台应用

请选择你的系统

Windows
Linux
移动端

Chrome
Edge
Firefox
Tor

纽约时间比加州时间早三个小时，
New York is 3 hours ahead of California,

但加州时间并没有变慢。
but it does not make California slow.

有人 22 岁就毕业了，
Someone graduated at the age of 22,

但等了五年才找到好的工作！
but waited 5 years before securing a good job!

有人 25 岁就当上 CEO，
Someone became a CEO at 25,

却在 50 岁去世。
and died at 50.

也有人迟到 50 岁才当上 CEO，
While another became a CEO at 50,

然后活到 90 岁。
and lived to 90 years.

有人依然单身，
Someone is still single,

同时也有人已婚。
while someone else got married.

奥巴马 55 岁就退休，
Obama retires at 55,

川普 70 岁才开始当总统。
but Trump starts at 70.

世上每个人本来就有自己的发展时区。
Absolutely everyone in this world works based on their Time Zone.

身边有些人看似走在你前面，
People around you might seem to go ahead of you,

也有人看似走在你后面。
some might seem to be behind you

但其实每个人在自己的时区有自己的步程。
But everyone is running their own RACE, in their own TIME.

不用嫉妒或嘲笑他们。
Don’t envy them or mock them.

他们都在自己的时区里，你也是！
They are in their TIME ZONE, and you are in yours!

生命就是等待正确的行动时机。
Life is about waiting for the right moment to act.

所以，放轻松。
So, RELAX.

你没有落后。
You’re not LATE.

你没有领先。
You’re not EARLY.

在命运为你安排的属于自己的时区里，一切都准时。
You are very much ON TIME, and in your TIME ZONE Destiny set up for you.

当我们出生时，我们被初始化。

外貌身材是我们的 UI，生活是我们的核心业务。

在整个生命周期内，我们需要不断地学习，掌握各种技能，不断地增长自己的阅历，接触更多的人和事。

期间，我们会遇到各种各样的 BUG，我们需要不停地调试，修复，优化甚至是重构。

但同时，这个世界中有我们喜欢的人，有我们所热爱的事情。

生活既是我们的甲方，又是我们的乙方。

善良正直，温柔体贴，风趣幽默，知足上进。。。

我们每个人都应该做自己的产品经理，清晰我们每一步前进的方向，不断地自我突破，自我迭代。

浑浑噩噩，当我意识到要切切实实规划自己未来的时候，已经 21 岁了。

但也还好，才 21 岁，未来充满着无限可能。

过去一年里吃药、检查、手术，检查、康复、吃药、检查、吃药终于看到希望

承蒙时光不弃，承蒙还有人鼓励，接下来勇敢地去追逐自己的未来吧！

祝自己 21 岁生日快乐🎂，生活值得被热爱❤️

收到的礼物：

你所期待的，正是我所热爱的。

快过年了，给博客加个灯笼吧~

挂两边

<style>
    @media only screen and (min-width: 1124px) {
        .nav-menu {
            padding-right: 96px;
        }
    }
    @media only screen and (max-width: 760px) {
        .deng-box, .deng-box1 {
            width: 40%;
        }
        .right {
            float: left!important;
        }
    }
    @media only screen and (min-width: 768px) and (max-width: 1024px) {
        .right {
            float: left!important;
        }
    }
    .deng-box {
        position: fixed;
       /* top: -30px; */
        top: 13px;
        right: -20px;
        z-index: 999;
    }
    .deng-box1 {
        position: fixed;
        top: 13px;
        /* right: 10px; */
        z-index: 999;
    }
    .deng-box1 .deng {
        position: relative;
        width: 120px;
        height: 90px;
        margin: 50px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.8);
        border-radius: 50% 50%;
        -webkit-transform-origin: 50% -100px;
        -webkit-animation: swing 5s infinite ease-in-out;
        box-shadow: -5px 5px 30px 4px rgba(252, 144, 61, 1);
    }
    .deng {
        position: relative;
        width: 120px;
        height: 90px;
        margin: 50px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.8);
        border-radius: 50% 50%;
        -webkit-transform-origin: 50% -100px;
        -webkit-animation: swing 3s infinite ease-in-out;
        box-shadow: -5px 5px 50px 4px rgba(250, 108, 0, 1);
    }
    .deng-a {
        width: 100px;
        height: 90px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.1);
        margin: 12px 8px 8px 10px;
        border-radius: 50% 50%;
        border: 2px solid #dc8f03;
    }
    .deng-b {
        width: 45px;
        height: 90px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.1);
        margin: -4px 8px 8px 26px;
        border-radius: 50% 50%;
        border: 2px solid #dc8f03;
    }
    .xian {
        position: absolute;
        /* top: -20px; */
        top: -69px;
        left: 60px;
        width: 2px;
        /*  height: 20px; */
        height: 70px;

        background: #dc8f03;
    }
    .shui-a {
        position: relative;
        width: 5px;
        height: 20px;
        margin: -5px 0 0 59px;
        -webkit-animation: swing 4s infinite ease-in-out;
        -webkit-transform-origin: 50% -45px;
        background: #ffa500;
        border-radius: 0 0 5px 5px;
    }
    .shui-b {
        position: absolute;
        top: 14px;
        left: -2px;
        width: 10px;
        height: 10px;
        background: #dc8f03;
        border-radius: 50%;
    }
    .shui-c {
        position: absolute;
        top: 18px;
        left: -2px;
        width: 10px;
        height: 35px;
        background: #ffa500;
        border-radius: 0 0 0 5px;
    }
    .deng:before {
        position: absolute;
        top: -7px;
        left: 29px;
        height: 12px;
        width: 60px;
        content: " ";
        display: block;
        z-index: 999;
        border-radius: 5px 5px 0 0;
        border: solid 1px #dc8f03;
        background: #ffa500;
        background: linear-gradient(to right, #dc8f03, #ffa500, #dc8f03, #ffa500, #dc8f03);
    }
    .deng:after {
        position: absolute;
        bottom: -7px;
        left: 10px;
        height: 12px;
        width: 60px;
        content: " ";
        display: block;
        margin-left: 20px;
        border-radius: 0 0 5px 5px;
        border: solid 1px #dc8f03;
        background: #ffa500;
        background: linear-gradient(to right, #dc8f03, #ffa500, #dc8f03, #ffa500, #dc8f03);
    }
    @font-face {
        font-family: "华文行楷";
        src: url('https://cdn.jsdelivr.net/gh/small-rose/small-rose.github.io/box/font/huawenxingkai.ttf');
    }
    .deng-t {
        font-family: 华文行楷;
        font-size: 26px;
        color: #dc8f03;
        font-weight: bold;
        line-height: 44px;
        text-align: center;
    }
    .night .deng-t,
    .night .deng-box,
    .night .deng-box1 {
        background: transparent !important;
    }
    @-moz-keyframes swing {
        0% {
                -moz-transform: rotate(-10deg)
        }
        50% {
             -moz-transform: rotate(10deg)
        }
        100% {
                -moz-transform: rotate(-10deg)
        }
    }
    @-webkit-keyframes swing {
        0% {
                -webkit-transform: rotate(-10deg)
        }
        50% {
                -webkit-transform: rotate(10deg)
        }
        100% {
                -webkit-transform: rotate(-10deg)
        }
    }
</style>
<div class="denglong" id="chunjie">
<div class="deng-box">
    <div class="deng">
        <div class="xian"></div>
        <div class="deng-a">
            <div class="deng-b"><div class="deng-t">喜迎</div></div>
        </div>
        <div class="shui shui-a"><div class="shui-c"></div><div class="shui-b"></div></div>
    </div>
</div>
<div class="deng-box1">
    <div class="deng">
        <div class="xian"></div>
        <div class="deng-a">
            <div class="deng-b"><div class="deng-t">春节</div></div>
        </div>
        <div class="shui shui-a"><div class="shui-c"></div><div class="shui-b"></div></div>
    </div>
</div>
<!-- 元宵节灯笼样式结束 -->
</div>
</header>
<script>
    if((new Date().getMonth()) > 1){
        $('.denglong').css('display', 'none');
    }else{
        $('.denglong').css('display', 'block');
    }
</script>

挂右边

<style>
    @media only screen and (min-width: 1124px) {
        .nav-menu {
            padding-right: 96px;
        }
    }
    @media only screen and (max-width: 760px) {
        .deng-box, .deng-box1 {
            width: 40%;
        }
        .right {
            float: left!important;
        }
    }
    @media only screen and (min-width: 768px) and (max-width: 1024px) {
        .right {
            float: left!important;
        }
    }
    .deng-box {
        position: fixed;
       /* top: -30px; */
        top: 13px;
        right: -20px;
        z-index: 999;
    }
    .deng-box1 {
        position: fixed;
        top: 13px;
        /* right: 10px; */
        z-index: 999;
    }
    .deng-box1 .deng {
        position: relative;
        width: 120px;
        height: 90px;
        margin: 50px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.8);
        border-radius: 50% 50%;
        -webkit-transform-origin: 50% -100px;
        -webkit-animation: swing 5s infinite ease-in-out;
        box-shadow: -5px 5px 30px 4px rgba(252, 144, 61, 1);
    }
    .deng {
        position: relative;
        width: 120px;
        height: 90px;
        margin: 50px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.8);
        border-radius: 50% 50%;
        -webkit-transform-origin: 50% -100px;
        -webkit-animation: swing 3s infinite ease-in-out;
        box-shadow: -5px 5px 50px 4px rgba(250, 108, 0, 1);
    }
    .deng-a {
        width: 100px;
        height: 90px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.1);
        margin: 12px 8px 8px 10px;
        border-radius: 50% 50%;
        border: 2px solid #dc8f03;
    }
    .deng-b {
        width: 45px;
        height: 90px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.1);
        margin: -4px 8px 8px 26px;
        border-radius: 50% 50%;
        border: 2px solid #dc8f03;
    }
    .xian {
        position: absolute;
        /* top: -20px; */
        top: -69px;
        left: 60px;
        width: 2px;
        /*  height: 20px; */
        height: 70px;

        background: #dc8f03;
    }
    .shui-a {
        position: relative;
        width: 5px;
        height: 20px;
        margin: -5px 0 0 59px;
        -webkit-animation: swing 4s infinite ease-in-out;
        -webkit-transform-origin: 50% -45px;
        background: #ffa500;
        border-radius: 0 0 5px 5px;
    }
    .shui-b {
        position: absolute;
        top: 14px;
        left: -2px;
        width: 10px;
        height: 10px;
        background: #dc8f03;
        border-radius: 50%;
    }
    .shui-c {
        position: absolute;
        top: 18px;
        left: -2px;
        width: 10px;
        height: 35px;
        background: #ffa500;
        border-radius: 0 0 0 5px;
    }
    .deng:before {
        position: absolute;
        top: -7px;
        left: 29px;
        height: 12px;
        width: 60px;
        content: " ";
        display: block;
        z-index: 999;
        border-radius: 5px 5px 0 0;
        border: solid 1px #dc8f03;
        background: #ffa500;
        background: linear-gradient(to right, #dc8f03, #ffa500, #dc8f03, #ffa500, #dc8f03);
    }
    .deng:after {
        position: absolute;
        bottom: -7px;
        left: 10px;
        height: 12px;
        width: 60px;
        content: " ";
        display: block;
        margin-left: 20px;
        border-radius: 0 0 5px 5px;
        border: solid 1px #dc8f03;
        background: #ffa500;
        background: linear-gradient(to right, #dc8f03, #ffa500, #dc8f03, #ffa500, #dc8f03);
    }
    @font-face {
        font-family: "华文行楷";
        src: url('https://cdn.jsdelivr.net/gh/small-rose/small-rose.github.io/box/font/huawenxingkai.ttf');
    }
    .deng-t {
        font-family: 华文行楷;
        font-size: 26px;
        color: #dc8f03;
        font-weight: bold;
        line-height: 44px;
        text-align: center;
    }
    .night .deng-t,
    .night .deng-box,
    .night .deng-box1 {
        background: transparent !important;
    }
    @-moz-keyframes swing {
        0% {
                -moz-transform: rotate(-10deg)
        }
        50% {
             -moz-transform: rotate(10deg)
        }
        100% {
                -moz-transform: rotate(-10deg)
        }
    }
    @-webkit-keyframes swing {
        0% {
                -webkit-transform: rotate(-10deg)
        }
        50% {
                -webkit-transform: rotate(10deg)
        }
        100% {
                -webkit-transform: rotate(-10deg)
        }
    }
</style>

<style>
    @media only screen and (min-width: 1124px) {
        .nav-menu {
            padding-right: 96px;
        }
    }
    @media only screen and (max-width: 760px) {
        .deng-box, .deng-box1 {
            width: 40%;
        }
        .right {
            float: left!important;
        }
    }
    @media only screen and (min-width: 768px) and (max-width: 1024px) {
        .right {
            float: left!important;
        }
    }
    .deng-box {
        position: fixed;
        top: -40px;
        right: -20px;
        z-index: 999;
    }
    .deng-box1 {
        position: fixed;
        top: -30px;
        right: 10px;
        z-index: 999;
    }
    .deng-box1 .deng {
        position: relative;
        width: 120px;
        height: 90px;
        margin: 50px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.8);
        border-radius: 50% 50%;
        -webkit-transform-origin: 50% -100px;
        -webkit-animation: swing 5s infinite ease-in-out;
        box-shadow: -5px 5px 30px 4px rgba(252, 144, 61, 1);
    }
    .deng {
        position: relative;
        width: 120px;
        height: 90px;
        margin: 50px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.8);
        border-radius: 50% 50%;
        -webkit-transform-origin: 50% -100px;
        -webkit-animation: swing 3s infinite ease-in-out;
        box-shadow: -5px 5px 50px 4px rgba(250, 108, 0, 1);
    }
    .deng-a {
        width: 100px;
        height: 90px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.1);
        margin: 12px 8px 8px 10px;
        border-radius: 50% 50%;
        border: 2px solid #dc8f03;
    }
    .deng-b {
        width: 45px;
        height: 90px;
        background: #d8000f;
        background: rgba(216, 0, 15, 0.1);
        margin: -4px 8px 8px 26px;
        border-radius: 50% 50%;
        border: 2px solid #dc8f03;
    }
    .xian {
        position: absolute;
        top: -20px;
        left: 60px;
        width: 2px;
        height: 20px;
        background: #dc8f03;
    }
    .shui-a {
        position: relative;
        width: 5px;
        height: 20px;
        margin: -5px 0 0 59px;
        -webkit-animation: swing 4s infinite ease-in-out;
        -webkit-transform-origin: 50% -45px;
        background: #ffa500;
        border-radius: 0 0 5px 5px;
    }
    .shui-b {
        position: absolute;
        top: 14px;
        left: -2px;
        width: 10px;
        height: 10px;
        background: #dc8f03;
        border-radius: 50%;
    }
    .shui-c {
        position: absolute;
        top: 18px;
        left: -2px;
        width: 10px;
        height: 35px;
        background: #ffa500;
        border-radius: 0 0 0 5px;
    }
    .deng:before {
        position: absolute;
        top: -7px;
        left: 29px;
        height: 12px;
        width: 60px;
        content: " ";
        display: block;
        z-index: 999;
        border-radius: 5px 5px 0 0;
        border: solid 1px #dc8f03;
        background: #ffa500;
        background: linear-gradient(to right, #dc8f03, #ffa500, #dc8f03, #ffa500, #dc8f03);
    }
    .deng:after {
        position: absolute;
        bottom: -7px;
        left: 10px;
        height: 12px;
        width: 60px;
        content: " ";
        display: block;
        margin-left: 20px;
        border-radius: 0 0 5px 5px;
        border: solid 1px #dc8f03;
        background: #ffa500;
        background: linear-gradient(to right, #dc8f03, #ffa500, #dc8f03, #ffa500, #dc8f03);
    }
    @font-face {
        font-family: "华文行楷";
        src: url('/fonts/华文行楷.ttf');
    }
    .deng-t {
        font-family: 华文行楷;
        font-size: 26px;
        color: #dc8f03;
        font-weight: bold;
        line-height: 44px;
        text-align: center;
    }
    .night .deng-t,
    .night .deng-box,
    .night .deng-box1 {
        background: transparent !important;
    }
    @-moz-keyframes swing {
        0% {
                -moz-transform: rotate(-10deg)
        }
        50% {
             -moz-transform: rotate(10deg)
        }
        100% {
                -moz-transform: rotate(-10deg)
        }
    }
    @-webkit-keyframes swing {
        0% {
                -webkit-transform: rotate(-10deg)
        }
        50% {
                -webkit-transform: rotate(10deg)
        }
        100% {
                -webkit-transform: rotate(-10deg)
        }
    }
</style>
<div class="denglong" id="chunjie">
<div class="deng-box">
    <div class="deng">
        <div class="xian"></div>
        <div class="deng-a">
            <div class="deng-b"><div class="deng-t">喜迎</div></div>
        </div>
        <div class="shui shui-a"><div class="shui-c"></div><div class="shui-b"></div></div>
    </div>
</div>
<div class="deng-box1">
    <div class="deng">
        <div class="xian"></div>
        <div class="deng-a">
            <div class="deng-b"><div class="deng-t">春节</div></div>
        </div>
        <div class="shui shui-a"><div class="shui-c"></div><div class="shui-b"></div></div>
    </div>
</div>
<!-- 元宵节灯笼样式结束 -->
</div>
</header>
<script>
    if((new Date().getMonth()) > 1){
        $('.denglong').css('display', 'none');
    }else{
        $('.denglong').css('display', 'block');
    }
</script>

• 面试犹如博弈，是你和面试官互相吹牛逼的过程。面试官会说他们公司多么多么的牛逼，虽然不是世界 500 强企业，但绝对是员工心目中的理想归宿。你也要说你自己多么多么的酷炫，是万年一遇的完全符合公司需求的全能型人才

如何包装

上面的话只是说说，如果你真照我说的去做，估计你离 fail 不远了，那如何更好的包装自己？首先要体现在简历上面。能在简历上体现高大上的地方就是工作经历了，所以一定不能乱写。要把你之前公司的职位需求写在上面，如果不知道怎么写，随便在网上找一个职位需求即可，但是记住，上面必须是你做过，或者你了解的，不然面试一问，就会露馅！

这里补充一下，如果想让自己更加牛逼，不妨写点项目经验。如果你说，我并没有参加过项目啊，没关系啊，把你在公司日常的工作，写成项目即可。这个项目可以写的非常庞大，但是记得，你只负责里面一个模块，这样可以把面试官问题，限制在这个技术点，不然面试官真以为你是全才，那问题就多了。

包装细节

然后在面试前，尽可能的当前职位发展趋势，以及最先进的技术，不是要求你会，了解即可，在面试中可以聊聊对它们独到的见解，绝对可以给你逼格加分。

最后在面试中，如果面试官问你简历中的一些细节时，一定做到收放自如。例如问你一个技术点时，会的话就简单描述，切忌长篇大论，因为言多必失。当问到不会的技术点时，如果是新技术，那就直言坦白，就算最终没有通过面试，至少咱诚信没扣分。如果这个技术你有听过，但是一时半会想不起来，那就说这个技术在项目中有，但不是你负责，曾接触过，有些印象，借助资料可以完成。

说来惭愧，我知道的的为数不多的法学相关的知识像个是从罗老师的视频里要不就是公司里打官司学的，罗老师作为一个算是名利双收的人吧，他谦称自己是法学殿堂的门童，字里行间没有一丝一毫的高高在上，这样自省谦逊的品质也是我最想学习的，书里讲了一些经典案例，辛普森杀妻案；电车难题，不知知网还有N号房事件等等，从法律的专业角度来解析这样的问题，就算是没有法学基础也不会觉得读不懂这边的金句特别多.

唯愿公平如大水滚滚使公义如江河涛涛。

人生唯一确定的就是不确定的人生

人永远不要再自己看重的事情上附着不加边际的价值。

智力和智慧是两码事，很多人有智力，但不一定有智慧。

拒绝读书当然是一种愚蠢，但是因为读书而滋生，骄傲与傲慢是一种更大的愚蠢。

想说说我自己比较喜欢的几个点，在是否支持废除死刑这样的问题上避讳的说，他曾经也支持废除死刑但是后来他有写

对于谋杀这些最恶劣的犯罪，只有剥夺生命才能体现对被害人生命的尊重

我之前都是从来没有想过行嘛，因为我觉得是需要死刑，这样的一种惩罚或者威慑着让坏人可能更加的珍惜生命，但我忽略了被害人忽略了死者，没有人有资格替被害者原谅加害者，但我想这个问题的时候居然就从无论是社会秩序，人道主义甚至是资源利用率这些方面去想，完全忽略了对于被害者的尊重，很庆幸我现在意识到这一点了，人总会有这样那样偏颇的认知嘛，反正我是觉得在我有限的生命里认识到一点是一点嘛.

还有一段关于性犯罪，滥用信任地位的犯罪，如果行为人与被害人存在信任关系，如存在监护、教育、照顾等关系，由于当事人双方地位不平等，被害人尤其是未成年人无法做出真正成熟理性的选择，他们对性行为的同意是无效的，与之发生性行为可能侵犯其性自治权，对此，许多国家都有滥用信任关系谋取性利益的犯罪。

书中举了例子，像师生恋在某个地方某个时间段也算是强奸，在读书中超越有限的今生这一章中罗老师写。

在世界读书日我应邀分享自己的读书心得，说来还是有点惶恐不安，我是一个非常普通的老师，充满着人人都可能有的偏见、愚蠢、傲慢、自欺与虚荣。我平时没什么爱好，读书是我打发时间，对抗虚无的方式，读书心得也仅代表个人的经验之谈。

这一段我很喜欢一个本充满智慧，理应高高在上的灵魂，却愿意俯下身坦诚和谦卑，真心实意的继续求知，并且能帮助很多人，罗老师有一句话很出名（引用的是陀思妥耶夫斯基的）

爱具体的人，而非抽象的人，

想象中的人类越可爱，越是觉得身边之人乏味恶心，因为抽像的人类如此可爱，而具体的人如此麻烦，对抽像的人类的爱是无需付出代价的，凭空想象，收放自如。

但对具体的人的爱则总是要投入大量的时间和精力。然而真正的爱一定是要付出代价的牺牲越大，爱心也就越大，无需付出代价的爱不是为了欺骗自己，就是为了欺骗他人。

罗老师也讲了小王子与他的玫瑰，你说世界上有那么多玫瑰为什么要在一朵玫瑰上投入全部的精力，为什么不住到花园里去呢

苏格拉底有一句话说人心中的欲念是一个筛子，筛子装不满水，无论多少欲念都填满不了人心，所以人的欲念一定要建立在一个具体的事物之上，这样你才会有真实的满足感，否则你不可能有满足感。

我们终究是活在这个现实的社会里，需要与真实的人建立联系构筑羁绊。去产生一些有益面向的社会兴趣，这是为了社会的持续发展也是为了让我们活过这短短时间，也不至于后悔说白来一趟，爱父母爱朋友爱同一个教室上课的同学爱同一张办公桌上的同事爱老板爱便利店店员而非爱“人类”

威廉詹姆斯有一部小说，说的是一会贵妇人在影院里为剧中人物的悲惨命运哭啜泣不已，但他的马夫却在戏院外面冻得快要死去

抽象的人永远无法代替具体的人，愿我们能够走出这种习以为常的伪善，在每一个岗位中勤劳度日不负所托。

希望我们都能像罗老师所说，走进真实的世界，关注真实的人，拥有真实的友谊

最后以这本书的结尾结尾吧

前方的道路不可预知，有着各种可能，生命充满的神祕莫测祝各位一路平安。不悲伤，不犹豫，不彷徨，但求理解。

最近看了一句话说 " 人生是旷野，而非轨道。" 那一刻有被安慰到。

活在既定秩序下的我们习惯了按部就班地完成自己的使命，你看前面的人浩浩荡荡走在这条路上，觉得自己也不能落下。于是奔波于三十岁结婚生子，四十岁扬名立万的途中。

一旦脚步慢了、步伐乱了就开始慌张，为什么别人都结婚了就我还单身？为什么别人都赚到大钱了就我还在打工？为什么大家都能在大城市坚持下去就我想回家？

可是为什么你要拿别人的轨迹丈量自己的人生？

在你的人生版图里，你才是实打实的坐标系和圆心，关于人生的种种蔓延都应该以你为中心，向左向右，向东向西，无论怎么走，都是往前走。

不要害怕自己与别人不同，因为组成你我的细胞和物质本身就有差异。

请你给自己松松绑，允许我们与他人有不同的选择和方向，允许有不同的生命线和时间轴，允许一切发生。

就像海灵格在《我允许》中说的： " 我允许任何事情的发生。我允许，事情是如此的开始，如此的发展，如此的结局。 "

祝你，一切都好。

2022年度总结不发了，虽然已经写好了在后台但是不发布了，用她的一句话来说就是：“可以但没必要。”这可能也是我六七年以来第一次不发布年度总结了吧，以前我从来不删自己写过的文章，但这一次破例了。

说说近况吧。

大家都知道了我最近在做一件什么事了吧，行业信息茧房的行为非常严重国内技术持续被封锁，大厂不放开交流机会，技术垄断授权行为严重，吃相难看，把各位消费者当弱智（我都不用傻子这个词了因为就是纯粹就是当成弱智），新人进入行业不知该如何发展该往那个方向发展，他们的上升空间永远被限制在一个可控的空间内发展，我见过一些比我还有天赋的人因为这种内外勾结永远都没办法进入更大的平台发展，永远局限于那一亩三分地，我们想打破这个局面从从9月确定要做这件事开始就承受着巨大的压力因为有过前车之鉴我大概知道我们会面临着什么威胁，也清楚明白我们即将面对的是什么，但到了后面事态越来越严重甚至到了我们无法控制的局面因为我们发现了一个更重大的事，由于种种由于请原谅我不能跟大家细说一二，我们终于也明白了为什么对方可以什么都知道，为什么他们可以敢如此嚣张—明目张胆。

上个月我收到过最多的就是质疑的声音有各位网友的，有身边朋友的（他们仅仅是出于我身体健康的考虑），当然肯定少不了家人的，还有她。

事态既然发展到这种地步了所以这事就此停止吧。我知道大家非常的不舍但我不想再看到有人因我受伤了。今年比赛结束后我也将退出这个行业了，在这个行业里我得到了很多成长，遇到了很多非常牛的人，见识跟眼界都得到了很大的提升，但也失去了很多东西比如曾经快乐的自己。我也累了，从此这个行业将消失一位自以为是的理想主义者。

身体

该死的新冠啊，上一次的检查结果第一次出现好转了，阳了一次这次检查不仅没一点好转反而比之前更严重了，医生说了一句话：早日准备手术吧，越早对你的伤害越小。也是该安排入日程了，但我也真的累了每天早上起来都特别难受特别的疼。近期也开始吃起了安眠药了可能是因为压力太大了吧已经没办法自行入睡了。但不知道为啥的是我已经连续快一个月每次睡觉都能梦到她，今天是第24天。

生活

这周我关掉了所有的IM即时通讯软件，关掉了朋友圈，关掉了Twitter通信，关掉了邮箱，什么事情都不想放空了大脑，玩了一下Xbox，以至于我的iPad打开是这样的。

然后还是打算出去走走吧，不然巨大的心理压力没地方释放我自己都害怕那天想不开了。

这两天非常感谢以下网友给我带来了为数不多的快乐虽然只有半个多小时。谢谢

以下是游戏的小插曲

排队开崩

真心崩不过啊，他们的车都好快。

开始整起花活了

这游戏怎么有嘟嘟嘟啊，开始英雄联盟起来了😂😂😂

起飞啦，起飞，艾 飞

真不错啊真不错，比赛里还是要看我手动挡，直线加速你们随便来崩我，我认了好吧比赛里到被我崩了吧 ，弯道快才是真的快[dog]

别像弱智一样提问

Stop-Ask-Questions-The-Stupid-Ways

提问的智慧

• https://github.com/oldratlee/translations/blob/master/how-to-ask-questions-the-smart-way/README.md

你真的准备好了吗？

感谢群友 for you 提供

避免 xy-problem

• 参考地址: http://xyproblem.info/

XY Problem 表示

1. 提问者想要解决 原问题 X ，且觉得解决了 引申问题 Y 就能解决 X 问题
2. 提问者对外提出了解决 Y 的的请求
3. 回答者帮助提问者解决 Y 问题。（浪费了回答者和提问者双方的时间）

然而, 最终 Y 问题可能并不是 X 问题的一个合适的解决方法
因此， 提问者要避免创造这样的修罗场, 需要学会在问题之初就准确描述自己的根本问题。 学会描述问题

提问前你必须需要知道的事情

1. 要知道， Free 的正确翻译是 自由，而非 免费。
2. 要知道，愿意回答问题的人，都是 可爱 的人。
3. 要知道，向帮助你的人 付费 是一个高尚的行为。即使回答你的人不是为了钱。
4. 要知道，花钱买时间是一个常识。如果你不能认同，要么你钱包穷，要么你思想穷。
5. 要知道，给对方发工资的不是你或者你老板。
6. 要知道，提问的时候你才是 孙子，帮助你的人是 大爷。
7. 要知道，不回答你的问题对其他人没有任何损失。
8. 要知道，准确描述一件事情是一项基本生存技能。要学会 《提问的智慧》
9. 要知道，搜索是一项基本生存技能，学不会用 Google 的话，你可能真的不适合你所从事的行业。
10. 要知道，英文是一项基本生存技能，不认识英文的话，你可能真的不适合你所从事的行业。

幼儿园的小朋友都知道要有礼貌

请问
  ...问题描述...
谢谢

学会描述问题

向别人提问的时候，要学会正确的描述问题。
把对方当成你的老板，你在给他做报告。要用最精炼的文字和图片，向对方阐述明白一个事情的来龙去脉。
要知道，你不是我追的妹子，我没有时间来猜你想要什么。
记住，给别人的条件越多，你的问题解决越快。因为这不是解密游戏。

1. 请问一个关于 什么 的问题。
2. 我想要达到 什么样 效果，但是我这样做出现了 什么样 的问题。
3. 报错日志是 这样 的。（要 学会 画关键字）
4. 我尝试过 什么 方法来解决。
5. 我尝试搜索过了 什么 关键字，在里面找到了 这些 URL 的回答，尝试了还是没有解决问题。
6. 我用的是 什么 操作系统，版本号是多少。
7. 我用的是 什么 软件，版本号是多少。
8. 谢谢

千万别认为只有别人帮助你之后才需要说 谢谢。

学会什么时候贴图

像这种，IM 自动转义表情，贴出来的问题全是表情。

学会什么时候要圈出重点

千万不要认为别人的频率和你是同步的，然后像这样扔出一张图一个表情就了事了。

在工作中， 你@的人可能会多问一句什么情况。 但是在 IM 聊天群里面，就没有这么好运气了。

如下很难吗？

@xxx，我这边访问不了 git 仓库。
环境是: 环境是什么。

学会什么时候贴文字

什么是弱智一样的提问

萌新滚粗

以下内容选自观众投稿，非本人实际经历。

余华说， " 没有什么比时间更具有说服力了，因为时间无需通知我们，就可以改变一切。 "

深爱过的人，走散了；烦恼过的事，平息了；曾经的执着与痛痒，慢慢变成了现在的云淡风轻。

而在所有的失去中，我最怀念的始终是我自己。

我已经很久不用QQ了，前段时间为了传文件重新打开了它，顺带看了一下QQ空间。

上一次更新状态还是2019年的6月，那会儿我刚大学毕业，发了一句 " 再见了 " ，没想到之后就真的再见了。

顺着时间线往前翻，我看到了以前的自拍，说实话又土又丑，但配的文案却是 " 又是美美的一天 " ，当年的我可真是太自信了。

2016年，我经历了大学第一场挂科，是传统特色很浓的体育课 " 太极拳 " ，整个年级只有两个人挂科，另一个是刚来中国不久的俄罗斯妹子。

毫无意外，我成了大笑话，但我自己还挺想得开，更新了一条说说 " 算了，一觉醒来还会是新的一天 " ，这心态实在是棒极了。

2017年，我喜欢上社团的一个男生，在空间写了一篇4000多字的青春疼痛文学，然后趁着酒劲向他表白了。

虽然惨遭拒绝，但我没颓废、没落寞，大哭一场后留下了一条心情， " 没缘分的就别强求了，你值得更好的。 "

不得不感慨，那个时候的我好洒脱，要是换作现在，可能都没勇气冲过去告白。

确实，和从前相比，现在的我真的又怂又丧气。

碰到棘手的工作，会担心到晚上睡不着，遇到喜欢的人，也总是犹犹豫豫。

偶尔参加长辈安排的相亲局，还下意识地在心里劝自己， " 别挑三拣四了，下一个未必比这个强。 "

我不再发素面朝天的自拍了，每次都是找各种角度再用美颜相机精修好久，可依旧没胆子将照片发出去。

也不在朋友圈给自己加油打气了，而是经常因为不顺心的事，独自在深夜哭得震耳欲聋。

突然有点羡慕当初那个 " 不知天高地厚 " 、 " 没心没肺且极度自信 " 的自己，快乐的心情会被无限放大，糟糕的琐事也不会占用太多时间。

这让我想起了张韶涵的那句歌词， " 当世界不知不觉地变了，有时候我怀念以前的我，做的梦虽然远远的，想象是一种快乐。 "

而此刻，那些快乐仿佛也顺着文字穿越到了眼前，让我现在的生活出现了些许星光。

就如同回顾老照片，看里面的好天气会感受到舒服和惬意；看里面的笑容会想起当时那些有意思的事；而现在看到曾经的自己，仿佛也被治愈了。

偶尔瞥见那些不开心的过往，我也会忍不住感叹，那么痛苦的事都挺过来了，还有什么过不去的呢。

过去的那个自己，就像是陪伴了我很久的知己，时常给我带来拥抱和安慰，治愈着当下内心的彷徨与忧伤。

以前零用钱只够买一朵雏菊，但足以让我蹦蹦跳跳地哼着歌回家了，如今每周都可以奖励自己一大束鲜花，那快乐是不是就该狠狠翻倍呢？

仔细想想，好多曾经期盼的事，现在都渐渐变成了现实。

比如我养了一条可爱的柴犬，我租了一间有大落地窗的房子，我做着喜欢的工作，用赚来的钱给在意的人买礼物。

那些留在逝去岁月的点点滴滴，时刻提醒着我：坏情绪会过去的、努力真的会有回报、担心的事未必都会发生、期待的美好却很可能在明天实现……

我虽然失去了某个年龄段的自己，但她们还是会在生命的轨迹上，不断地向今天传递能量。

正如《夏日终曲》里的一段话， " 我把细微事物收集起来，好在未来贫瘠的日子里，让过去的微光带给我温暖。 "

而这向过去借来的温暖，会守护着我更坚定地迈向未来，帮助我认真地过好接下来的每一天。

虽然人都会在经历一些事后，变得不一样，但真的没必要向那些鸡毛蒜皮的挫折低下热爱阳光的脑袋。

期待所有人都可以摆脱唉声叹气的自己，做自己人生的小太阳，投一束光，去照亮脚下、照亮充满希望的远方。

以上内容选自观众投稿。

以下内容选自观众投稿，非本人实际经历。

你也比往年更不爱发朋友圈了吗？

你的朋友圈也设置成了仅三天可见了吗？

你发一条朋友圈之前也会打了又删，删了又打，斟字酌句吗？

朋友圈的烟火气逐渐减少，我们已经变成为生活奔波的大人了。

前几天，我刷到一个大学同学的动态，她结束了北漂生活，带着大包小包回了老家。

我突然意识到我们上一次联系已经是一年前了，我点进她的朋友圈，想看看她近一年的生活状况，映入眼帘的除了那条 " 告别北漂生活 " 的动态，其他都是与工作相关的推文。

以前的她，会在朋友圈分享旅游照、安利附近的美食、吐槽奇葩事件；现在的她，在朋友圈分享最多的是产品软文，一句普通的节日祝福也会配上产品的宣传海报。

她好像退出了我的朋友圈，我再也无法从她的朋友圈中捕捉到她的喜怒哀乐，更无法得知她的生活近况。

成年人需要忙碌于工作，需要维系人际关系，需要精打细算过日子，有限的精力在奔波中被消耗，越长大就越难频繁在朋友圈分享生活。

反观自己，我也不再像从前一样将喜怒哀乐都一股脑往朋友圈塞，我只愿意挑选生活中好的那面在朋友圈展现。

仔细回想，还是能找到一些关于变化的蛛丝马迹。

两年前，我发了一条很丧气的朋友圈，大致的意思是觉得自己一事无成，工作多年也没能攒下多少存款。本以为能在朋友圈得到一些安慰，不料根本无人搭理。

一年前，我因为肠胃炎进了医院，发了个朋友圈吐槽诸事不顺，结果引起了爸妈的担忧，他们在电话那头反复叮嘱一个人在外面要好好吃饭，好好照顾自己。

成年人都在自己的生活中摸爬滚打，各有各的烦恼，很少有人愿意介入其他人的负面情绪，而我们的糟心事反而容易让远在千里之外的家人担忧。

于是，我发朋友圈的频率逐渐下降，也将朋友圈设置成了「仅三天可见」。

偶尔心血来潮想在朋友圈冒个泡的时候，也只会发一些积极向上的动态，比如开启了一段新恋情、拍了一套写真、减肥成功、结束了一场说走就走的旅行。

在某种程度上看，我仿佛从朋友圈中消失了，仿佛失去了一个展现生活的小小窗口，但其实仍然有一部分人自始至终都了解我的生活。

迷茫无措时，是那一部分人对我说 " 别怕 " ，给了我恰到好处的建议；失恋痛哭时，是那一部分人陪我喝酒聊天；受挫失望时，是那一部分人陪伴在我身边听我吐槽，告诉我 " 别给自己太大压力 " 。

那一部分人接住了我所有的负面情绪，然后跟我一起悄悄将我的狼狈藏了起来。他们是我在乎的也在乎我的人，他们不常出现在我的朋友圈，但却每时每刻都在参与我的生活。

朋友圈只是了解一个人生活近况的渠道之一，真正想关心我们的人，绝对不会只出现在朋友圈里。

Ta会点开对话框跟我们聊天问我们最近累不累，Ta会想方设法来跟我们见面，Ta会出现在我们生活中的很多角落。

随着年龄的增长，朋友圈逐渐没有了生活的痕迹是很平常的事。

那些消失在朋友圈的人，往往在现实中静默地成长、低调地成熟、慢慢地与生活对抗。

如果你在某天突然发现某人退出了你的朋友圈，如果你在某天突然意识到自己对某人的生活近况一无所知，如果你羡慕某个人的生活以为这个人一直过得好，只能说明你们的关系并没有想象中的那么好。

但也不必难过，因为一定存在一个跟你碎碎念的人，也一定存在一个愿意听你碎碎念的人，那些人才是真正重要的人。

以上内容选自观众投稿。

这一年大概是我长这么大最难熬的一年。

经历了行业寒冬、经历了返工困难、经历了反反复复居家隔离，经历了找房子搬家被坑……感觉这一年到处都充满了挑战。

曾经一度想按下加速键，赶紧结束这倒霉的一年。

可是真到了年末，又感觉时间过得好快，希望时间再延长一些。

现在距离2023年，还剩一个月了。

距离我们这一生的结束，还有多久呢？

那天我仔细算了一下：

我国的平均寿命是78岁，假设我还能活到78岁，那么我的一生大概有28,470天，而现在我已经过了20年，那么我还剩21,170天。

如果每天吃饭睡觉需要10个小时，那么我清醒的时间就还剩12,349天。

假如我这些年工作稳定，每天上班8小时，不加班、正常休假，50岁按时退休，那么这一生，真正留给我的时间，好像还剩1460天。

最后真正属于我一个人的时间，还剩多少呢？
我能陪伴家人的时间，又有多少呢？

这还是在完全健康正常的理想状态下，想到这里，我不禁陷入了沉思。

以前总觉得自己还二十岁出头，正年轻，有大把的时间可以挥霍。

可现在突然意识到，生命留给我的时间已经不多了。

那些你以为的人生漫长，到后来，不过是人生无常。

去年过年的时候，我舅爷去世了，因为胃癌。

在他走之前，经历了不少折磨。

因为进食困难，医生在他胃附近切了一个小口用来插管，然后用注射器往里面注射一些流食。

在医院待了两个月后，情况依然没有任何好转。

于是舅爷坚持要回家待着，说什么都不留在医院。

可能要离开的人，都是有预感的。

回家之后，他告诉小儿子，他想见见大家伙。

于是那段时间，所有的兄弟姐妹、儿子女儿、孙子孙女全从外地赶了回来。

最小的外孙，因为疫情原因，直到大年三十才到家。

那天晚上见完了最后一面，第二天早上舅爷就去世了。

大概是完成了最后一个心愿，所以走的时候，面容格外平和。

我问我妈，为什么舅爷不留在医院，说不定还能多活一段时间。

我妈说，其实舅爷心里有数，他知道自己时间不多了，所以不想浪费在医院里，他想把最后的时间，都留给最亲的人。

参加葬礼那天，我认真思考了一个问题：

如果我的人生只剩下最后一个月，我会把这些时间花在哪里呢？

是去旅游吗，看看那些我曾经向往但还没有去过的地方；

是去享受美食吗，把曾经喜欢吃的东西全都再吃一遍；

是去告别吗，见见那些老朋友、老同学，和他们一起回忆过往，然后一一告别。

最后想想，还是和家人在一起吧。何最爱的人在一起吧。

即使我们已经在一起几十年了，即使很多时候我们已经相看两厌了，即使我们已经没什么新鲜话题可以说了。

但是在人生最后的日子里，我依然希望守在我身边的人是他们。

即使他们围坐在我的床前，什么话都不说，就这样看着他们，就够了。

人这一生，陪伴自己时间最长的就是家人，父母看着我们出生、长大、结婚、生子，孩子们看着我们变老、生病、离开。

血脉相承，时间相连。

彼此之间最亲近，最相爱，也最不舍。

所以我还是想把最后的时间，都留给他们。

人这一生，每天都是倒计时。

有人把时间花在爱情上，去爱、去试错、去找到对的人，然后相伴到老；

有人把时间花在友情上，找到一个人生知己，一起去吃喝玩乐，享受人生；

有人把时间花在亲情上，陪妈妈聊天，陪爸爸钓鱼，听爷爷奶奶讲以前的故事。

不论哪种选择，只要是你想做的，那就是最好的选择。

人生苦短，学着把有限的时间花在真正值得的人和事上面吧。

那些错的人，已经过去的事，就不要再浪费时间纠缠了。

让过去过去，让未来到来，认真过好接下来的每一天。

我好像写不出稿子了。

最近一周，甚至最近一个月，我都没有写出一篇让自己满意的稿子。

生活毫无波澜，感情平平淡淡，工作更是一潭死水，怎么想都觉得没有可写的东西。

好像每个人的生命中，都会有这样的时刻。

原本好好的工作，突然就干不下去了；
原本好好的恋爱，突然就不想谈了；
原本好好的朋友，突然就不联系了。

于是我们开始怀疑自己，是不是做错了选择，还是自己本身就不配。

晚上睡不着的时候，我经常胡思乱想，回想那些我曾走过的路，遇见过的人，做过的决定。

我在想如果人生重来一次的话，我会不会做出不一样的选择，然后现在就会变得完全不一样。

比如当初填志愿的时候，如果我选了另一所大学，现在会不会还在继续读书深造呢；

比如毕业找工作的时候，如果我选了和专业完全对口的岗位，现在的工资会不会更高一些呢；

比如谈上一段恋爱的时候，如果我没有接受他的表白，现在会不会就没那么害怕开始新的感情了呢。

在某一瞬间，我的确觉得自己好像走错了很多路，不管是学习上、工作上还是感情上。

可后来想想，我又怎么能确定另一条路是对的呢？

如果重来一次，以我当时的心智和阅历，可能还是会做出同样的选择。

这个世界总是这样，有很多始料未及的打击，还有很多意想不到的相遇。

周末写不出稿子的时候，我一个人出去转了一圈。

晚上回家的时候，被一场突如其来的一场大雨困在了公交站。

跟我一起困在那里的，有十几岁的少年，有手拉手的情侣，有提着公文包的上班族，还有带着孩子的母亲……

少年抬头看了看天，然后把衣服上的帽子往头上一扣，直接冲进雨中离开了。一场雨而已，怕什么，少年有的是勇气；

旁边的情侣似乎并不着急，男生还拿出了手机帮女朋友拍照，换了很多角度拍了无数张照片。一场雨而已，怕什么，只要和喜欢的人在一起，什么天气都可以变得无比浪漫；

带孩子的那位母亲，随身带着一把小伞，虽然挡不住所有的风雨，但足够遮住孩子小小的身体。一场雨而已，怕什么，总有人愿意淋着雨帮你撑伞。

后来车站只剩下我和另一个提着公文包的上班族，我排了很久的队终于叫到了一辆出租车，刚准备离开，就看到男生的好哥们儿打着伞来接他了。

突然感觉很温暖，一场雨而已，怕什么，我们都有的是办法回家。

人生也是这样，每个人或多或少都会经历一段特别艰难的时光。

生活的窘迫、工作的失意、爱情的分分合合，但最后，我们都会挺过来的。

没必要因为一时的困顿而焦虑，也不必因此怀疑自我。

日生月落，总有黎明。

《允许自己虚度时光》一书中有这样一段话：

" 我慢慢明白了我为什么不快乐，因为我总是期待一个结果。

看一本书期待它让我变深刻，吃饭游泳期待它让我一斤斤瘦下来，发一条短信期待它被回复，对人好期待它回应也好，写一个故事说一个心情期待它被关注被安慰，参加一个活动期待换来充实丰富的经历。

这些预设的期待如果实现了，长舒一口气。

如果没实现呢？自怨自艾。

可是小时候也是同一个我，用一个下午的时间看蚂蚁搬家，等石头开花，小时候不期待结果，小时候哭笑都不打折。 "

很多时候，我们之所以感到焦虑，感到自我怀疑，不是因为自己真的不行，而是我们太急于求成了，我们总是希望所有事情都立竿见影。

却忘了命运的馈赠，往往发生在人生浮沉之后。

有句话说， " 无所求必满载而归。 "

当我们减少对自己的期待，降低对别人的依赖时，生活反而处处有惊喜。

所以啊，不必质疑自己的付出，也不必后悔曾经的抉择。

你所走的每一步路，都是在为将来做铺垫。

虽然东莞的天气不是很冷，但是吹了个半小时风，是的我又发烧了，但至少现在清醒了，这两天发生的事挺出乎意料的，有那么一刻我真的以为就这样了，但还好逃过一劫。

注意保暖鸭~

好的婚姻是什么？

一个二十多岁刚结婚的女人说， " 是爱情的延续。 "

一个熬过了七年之痒的男人说， " 是柴米油盐，是吵吵闹闹，是重新爱上。 "

一对六十多岁的大爷说， " 是有个老伴儿在身边。 "

不幸的婚姻，各有各的不幸；而幸福的婚姻，也各有各的不同。

朋友今年五月二十号结了婚，男生是她喜欢了十年的高中同学。

两个人当年在高中时就互相喜欢，只是当时一心准备高考，始终没有戳破那层窗户纸。

分数出来之后，两人相差二十几分，去了不同的大学，从此断了联系。

当所有人都以为他们会就此错过的时候，两个人又因为工作关系，在同一个城市偶然重逢。

没想到兜兜转转了一大圈，他们还是在一起了，像极了偶像剧。

那天去参加婚礼的时候，遇到了很多高中同学，大家都在感慨他们的缘分。

原来真的有人，能默默喜欢一个人十年；原来真的有爱情，能经受住时间的考验。

大概是命运安排好了，要这样发生吧。

那天讲婚礼誓词的时候，我哭得一塌糊涂。

朋友说我一直以为，那是我一个人小心翼翼暗恋的十年，没想到，那是我们的十年。 说着说着眼泪就出来了，然后两个人紧紧拥抱在一起。

看到他们幸福的样子，我真的打心底里为他们感到开心。那一刻，感觉自己又相信爱情了。

从小到大，有很长一段时间我是不相信爱情的，更不用说婚姻了。

因为身边的亲戚们也好，邻居们也好，似乎并没有几个家庭是幸福的。

从我记事开始，后门的邻居就经常吵架，三天一小吵，五天一大吵，严重的时候左邻右舍都会跑过去拉架；

我爸我妈也会经常怄气，因为抽烟、因为喝酒、因为没钱等等，这些年大大小小的吵闹可以说不下50次，以至于有段时间我非常想让他们离婚；

小姨跟她前夫结婚十几年，两个人生病了互不关心，做错事也没有道歉，除了孩子根本没什么共同话语，最后离婚的时候还闹得很难看，是打官司诉讼离的婚。

有时候看多了不幸的婚姻，真的很难去相信这世上有人能把婚姻经营得很好。

直到前几年的时候，我妈生了一场病，我爸整个人也跟着变得憔悴了很多。

他说，那段时间他每天晚上都睡不着，我妈一咳嗽，一大喘气，他就立马吓醒了，赶紧给我妈倒水、拿药。

我妈好了之后，他特别严肃地叮嘱说： " 咱俩都得把身体照顾好，以后孩子们长大了成家了就剩咱俩了，你可不能出事啊。 "

那个时候我才意识到，其实很多时候，不是我看到了太多不幸的婚姻，而是婚姻本身就起起伏伏，喜忧参半。

不能因为争吵，就定义了整个婚姻的不幸；
不能因为某方面不合，就定义了两个人的不合适；
也不能因为离婚，就定义了两个人从来没相爱过。

婚姻是一门深刻的学问，而我们都还是学生。

想起去年，我曾被一封写在药盒上的 " 情书 " 感动过。

南京69岁的李爷爷和老伴因为确诊新冠，被送到医院隔离治疗，但是因为入院时间不一样，两个人分在了不同的病房。

两个人青梅竹马，那段时间，是他们分开最久的一次。

老奶奶原本抗拒治疗，不接受心理辅导，也不想和家人视频，直到她收到了李爷爷写在药盒上的一封信。

上面写着：

老太婆：

这几天天气不好，但总归是要过去。我们也是没有办法，望你要克服困难，协助医生的工作。

你生我的气我不怪你，等过了这个时候，回家给你赔礼道歉吧。

把手机打开，孩子们很急。

   						 	死老头

我想，这大概就是爱情最好的样子吧。

经历了岁月的沉淀，经历了病魔的纠缠，最后还依然深爱着彼此，陪伴在彼此身边。

印证了那句话， " 陪伴是最长情的告白。 "

世间的夫妻有那么多对，不是每一对都恩恩爱爱，那么和谐，也不是每一对都吵吵闹闹，一地鸡毛。

大多数的夫妻，就是在鸡零狗碎中相互扶持，在起起落落后，不离不弃。

曾听过一段话 婚姻不是1+1=2，而是0.5+0.5=1。因为结婚之后，两个人都要各去掉一半的个性，才能组成美满的家庭

这世上没有百分百相契合的两个人，也没有从头到尾都一帆风顺的婚姻。

只有两个人都心甘情愿将自己由 " 1 " 变成 " 0.5 " 时，这样的婚姻关系才会稳定和谐。

有时候爱情不是因为看到了才相信，而是因为相信了才能看到。

一起看过日出日落，一起看过星星的人一定能记住很长很长时间，对吧！

我其实很喜欢日出，因为我觉得日出代表着活力与未来；昨日的逝去与今日的新生，如形容少年是“八九点钟的太阳”。看到的是日出时的壮美景观和朝发之气。

阳光温柔的照在身上

是二十岁的小子，一腔热血奋勇向前

是历经漫漫黑夜后的光明，令人向往。

注意：此方法有风险操作之前请提前备份原有文件

Win11 22H2（22621.819），USB打印机和电脑直接连接然后共享打印机，在其他电脑（Win7或Win10）无法添加共享打印机，提示0x00000709错误；之前在Win10的时候就因为补丁导致共享打印机有问题，后来出了补丁才解决，到了Win11 22H2又出现这个问题。大家可以尝试下载下面三个文件替换到C:\Windows\System32\目录然后重新启动即可。
spoolsv.exe
localspl.dll
win32spl.dll

以下是微软官方的解决方法引用：https://answers.microsoft.com/zh-hans/windows/forum/all/win11-22h2/bd0ee88e-d4c8-4444-b4ee-0e7f9e33db8f

可能

歌手： 李怡然

可能是月亮不会眨眼，

星星不会说话，

让你觉得孤单啦，

可能是太阳熬夜太晚，

云朵们都太懒，

忘了帮你编童话，

可能他出现在未来，

没出现在现在，

不小心搞乱你的时差，

可能是你所谓的转角，

是其他人的直线，

所以没法给你个回答，

一个人，

一直走，

一个很好很好的朋友，

一句话，

便足够，

我想要陪你很久很久，

如果我们终有一天变得很复杂，

一定是有颗种子在我心里生根发芽，

它听我讲话慢慢长大，

形成了不能愈合的伤疤，

可能是熟悉的地方没有风景，

所以你要去很远的地方找自己，

星星不会离开月亮，

我也不会离开你，

可能他出现在未来，

没出现在现在，

不小心搞乱你的时差，

可能是你所谓的转角，

是其他人的直线，

所以没法给你个回答，

一个人，

一直走，

一个很好很好的朋友，

一句话，

便足够，

我想要陪你很久很久，

如果我们终有一天变得很复杂，

一定是有颗种子在我心里生根发芽，

它听我讲话慢慢长大，

形成了不能愈合的伤疤，

可能是熟悉的地方没有风景，

所以你要去很远的地方找自己，

星星不会离开月亮，

我也不会离开你，

如果我们终有一天变得很复杂，

一定是有颗种子在我心里生根发芽，

它听我讲话慢慢长大，

形成了不能愈合的伤疤，

可能是熟悉的地方没有风景，

所以你要去很远的地方找自己，

星星不会离开月亮，

我也不会离开你。

以下内容转载于 蕊希 微信公众号：蕊希

早晨路过一家新开的花店，店主指着货架上娇艳的玫瑰花说：新店开业，那边所有的玫瑰，今天都是八八折。

我扭头看了一眼，最后却还是按照原价买了一束百合花。

或许，到了一定的年纪，真的会有不一样的心境。

若选择了曾经钟爱的玫瑰，就要接受它满身的刺，与其耗费大量的时间和精力打理它，不如过滤掉所有复杂的程序，选择一束纯洁的百合花。

我的意思是：随着年龄的增长，越来越多的人喜欢简单的东西，删繁就简，才是我们这个阶段该有的样子。

前段时间，我在知乎上认识了一个男孩。

添加好友后，我们没有一丝拘谨，很快便熟络了起来。

他的职业是程序员，身高180cm，喜欢打篮球，不抽烟不饮酒，还会点简单的厨艺……

重要的是，在他给我发来照片后，我觉得还蛮不错，加上整体条件与我的 " 伴侣画像 " 有很强的契合度，让我更是满心欢喜。

我觉得我们聊天的过程还挺舒服的，就像两个认识很久的老朋友那样，聊着现状，唠着家常。

我承认我是一个目标感很强的人，如果遇到自己喜欢的人，我一定会主动跟对方聊天。

在我发出信号后，也确实得到了回应。

所以那几天里，我不忙的时候会主动找他，他有空的时候也会主动找我。

这种有来有回的礼貌问候，让我们在短时间里建立起了初步信任。

没过几天，我直接表明了对他的好感，他也像往常一样给出确切的回应。

他说： " 我们可以多聊一聊，有机会见个面啥的。 "

那一刻，我的心里泛起了波澜，依旧天真地以为：人要对自己说过的每一句话负责，而我相信他是一个说话算数的人。

可是后来，这种关系很快便冷却，像一杯冰镇饮料，只剩下杯壁周围肉眼可见的水珠。

从那以后，互动式的聊天模式变成了单方面的主动。

当一个人不再主动与你分享日常，不再主动了解你的状况，那就是散场的开始。

所以，在我察觉到只有自己一个人依旧热情地发问，依旧满怀期待地等待答复时，又立马收回自己的真心。

大家都是成年人，喜欢和不喜欢，真的可以感受到。

我只有确定这个人他在坚定地走向我，只有确定我是他的偏爱和例外，而非可有可无时，才会心安，也才会更加坚定，甚至义无反顾。

我们就这样默契地回到陌生的角色，在我不主动找他的这段日子里，他也没有再主动找过我，也许，这才是最后的答案。

如果一个人不再关心你有没有按时吃饭，不再关注你生活的点点滴滴，甚至对你不闻不问，就证明，他对你其实并没有多大的兴趣。

你该做的，不是频繁地打扰，而是礼貌地退回自己的世界里，认真过好属于自己的生活。

喜欢你的人他不会跟你无话可说，他恨不得找很多很多话题，与你聊到天长地久。

如果他连 " 破冰 " 的话题都不愿找，那多半是没那么喜欢你。

你又何必次次试探，热情泛滥？

他是我单身这么久以来，即使在厨房手忙脚乱也会秒回消息的人，是我即使跟家人开着视频通话也会一直回复消息的人。

可这份喜欢，也只能到此为止了。

单身这么久的时间里，真的遇到过让我怦然心动的男孩，但唯独缺少那份心安。

身边很多同事都不理解，然后一遍遍地跟我确认， " 你这么优秀真的没有男朋友吗？ "

回到老家又要被人质问， " 是不是你要求太多，眼光太高？ "

我不会一遍遍地解释或者否认，而是用淡淡一笑来回应。

曾经有朋友问过我， " 你有没有发现，现在越来越多的人都不敢轻易地谈恋爱了？ "

我直接扭头望向他，淡定而不失尴尬地笑出了声， " 你说的不就是我吗？ "

而对于这个问题，现在我有了确切的答案。

这个世界上有很多人缺乏安全感，尤其是对待亲密关系。

比起恋爱过程中鸡毛蒜皮的小事，那些没有结果的结局更让人难堪。

害怕失去，害怕伤害，害怕承担不了最后的结果，于是拒绝了一切开始。

其实很多人并不是不想谈恋爱，大部分嘴上说不想谈恋爱的人，内心会更渴望一段感情，而只有在Ta确定对方真的可靠的情况下，才会大胆地迈出那一步。

虽然很慢，但很坚定。

如果问我什么时候会谈恋爱？

我的答案是，等到那个既喜欢又合适的人，又或者，等到自己实在撑不住的那一天。

Windows11原生支持的DoH有

Pv4

• Google：8.8.8.8 and 8.8.4.4
• Cloudflare：1.1.1.1 and 1.0.0.1
• Quad9：9.9.9.9 and 149.112.112.112

IPv6

• Google：2001:4860:4860::8888 and 2001:4860:4860::8844
• Cloudflare：2606:4700:4700::1111 and 2606:4700:4700::1001
• Quad9：2620:fe::fe and

但是，上面的这些在国内网络是无法正常使用的。输入其他的DoH服务的IP地址如223.5.5.5，DNS加密位置是灰色的，无法选择。

我们可以在CMD中使用命令去查看系统中的DoH：netsh dns show encryption

返回以下内容，原因是Windows11没有内置上国内的DoH服务的模板，我们需要手动添加

149.112.112.112 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://dns.quad9.net/dns-query
自动升级                : no
UDP 回退                : no

9.9.9.9 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://dns.quad9.net/dns-query
自动升级                : no
UDP 回退                : no

8.8.8.8 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://dns.google/dns-query
自动升级                : no
UDP 回退                : no

8.8.4.4 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://dns.google/dns-query
自动升级                : no
UDP 回退                : no

1.1.1.1 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://cloudflare-dns.com/dns-query
自动升级                : no
UDP 回退                : no

1.0.0.1 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://cloudflare-dns.com/dns-query
自动升级                : no
UDP 回退                : no

2001:4860:4860::8844 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://dns.google/dns-query
自动升级                : no
UDP 回退                : no

2001:4860:4860::8888 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://dns.google/dns-query
自动升级                : no
UDP 回退                : no

2606:4700:4700::1001 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://cloudflare-dns.com/dns-query
自动升级                : no
UDP 回退                : no

2606:4700:4700::1111 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://cloudflare-dns.com/dns-query
自动升级                : no
UDP 回退                : no

2620:fe::fe 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://dns.quad9.net/dns-query
自动升级                : no
UDP 回退                : no

2620:fe::fe:9 加密设置
----------------------------------------------------------------------
DNS-over-HTTPS 模板     : https://dns.quad9.net/dns-query
自动升级                : no
UDP 回退                : no

管理员权限，使用netsh添加DoH服务模板：

netsh dns add encryption server=[resolver-IP-address] dohtemplate=[resolver-DoH-template] autoupgrade=yes udpfallback=no

或者Powershell

Add-DnsClientDohServerAddress -ServerAddress '[resolver-IP-address]' -DohTemplate '[resolver-DoH-template]' -AllowFallbackToUdp $False -AutoUpgrade $True

比如我想添加阿里云DoH他们的DoH地址是https://dns.alidns.com/dns-query

我们输入就可以添加这条DoH配置

netsh dns add encryption server=223.5.5.5 dohtemplate=https://dns.alidns.com/dns-query autoupgrade=yes udpfallback=no

这条命令的意思是添加加密DoH的模板，服务器地址是223.5.5.5，DoH的地址是https://dns.alidns.com/dns-query，自动升级允许（当你的DNS是223.5.5.5的话就自动升级成DoH），回退不允许（只能使用DoH继续解析，不允许回退无加密的DNS解析）

此时再进行dns查询就都是加密的啦

虽然git诞生距今已有12年之久，网上各种关于git的介绍文章数不胜数，但是依然有很多人（包括我自己在内）对于它的功能不能完全掌握。以下的介绍只是基于我个人对于git的理解，并且可能生编硬造了一些不完全符合git说法的词语。目的只是为了让git通俗化，使初学者也能大概了解如何快速上手git。同时，下面所有讨论，我们都假设只使用一个分支，也就是主分支master的情况，虽然这种作法并不符合git规范，但是现实情况中绝大部分用户是直接在master分支上进行工作的，所以在这里我们不去引入更加复杂的各种分支的情况，也不涉及标签tag的操作，只讲在最简单的主分支上如何回退。

基本概念

3个步骤

工作区>暂存区>本地仓库>远程仓库

正常情况下，我们的工作流就是3个步骤，对应上图中的3个箭头线：

git add .
git commit -m "comment"
git push

• git add .把所有文件放入暂存区；
• git commit把所有文件从暂存区提交进本地仓库；
• git push把所有文件从本地仓库推送进远程仓库

4个区

git之所以令人费解，主要是它相比于svn等等传统的版本管理工具，多引入了一个暂存区(Stage)的概念，就因为多了这一个概念，而使很多人疑惑。其实，在初学者来说，每个区具体怎么工作的，我们完全不需要关心，而只要知道有这么4个区就够了：

• 工作区(Working Area)
• 暂存区(Stage)
• 本地仓库(Local Repository)
• 远程仓库(Remote Repository)

5种状态

以上4个区，进入每一个区成功之后会产生一个状态，再加上最初始的一个状态，一共是5种状态。以下我们把这5种状态分别命名为：

• 未修改(Origin)
• 已修改(Modified)
• 已暂存(Staged)
• 已提交(Committed)
• 已推送(Pushed)

检查修改

了解了基本概念之后，我们来谈一谈犯错误之后如何撤销的问题。首先，我们要了解如何检查这3个步骤当中每一个步骤修改了什么，然后才好判断有没有修改成功。检查修改的二级命令都相同，都是diff，只是参数有所不同。

已修改，未暂存

git diff

首先，我们来看一下，如果我们只是简单地在浏览器里保存了一下文件，但是还没有做git add .之前，我们如何检查有哪些修改。我们先随便拿一个文件来做一下实验：

我们在文件开头的第2行胡乱加了4个数字1234，存盘，这时文件进入了已修改状态，但是还没有进入暂存区，我们运行git diff，结果如下：

diff --git a/index.md b/index.md
index 73ff1ba..1066758 100644
--- a/index.md
+++ b/index.md
@@ -1,5 +1,5 @@
 ---
-layout: main
+1234layout: main
 color: black
 ---

git diff 的结果告诉我们哪些文件已经做了哪些修改。

已暂存，未提交

git diff --cached

现在我们把修改放入暂存区看一下。先执行git add .，然后执行git diff，你会发现没有任何结果：

这说明git diff这个命令只检查我们的工作区和暂存区之间的差异，如果我们想看到暂存区和本地仓库之间的差异，就需要加一个参数git diff --cached：

diff --git a/index.md b/index.md
index 73ff1ba..1066758 100644
--- a/index.md
+++ b/index.md
@@ -1,5 +1,5 @@
 ---
-layout: main
+1234layout: main
 color: black
 ---

这时候我们看到的差异是暂存区和本地仓库之间的差异。

已提交，未推送

git diff master origin/master

现在，我们把修改从暂存区提交到本地仓库，再看一下差异。先执行git commit，然后再执行git diff --cached，没有差异，执行git diff master origin/master，可以看到差异：

在这里，master就是你的本地仓库，而origin/master就是你的远程仓库，master是主分支的意思，因为我们都在主分支上工作，所以这里两边都是master，而origin就代表远程。

撤销修改

了解清楚如何检查各种修改之后，我们开始尝试各种撤销操作。

已修改，未暂存

如果我们只是在编辑器里修改了文件，但还没有执行git add .，这时候我们的文件还在工作区，并没有进入暂存区，我们可以用：

git checkout .

或者

git reset --hard

来进行撤销操作。

可以看到，在执行完git checkout .之后，修改已被撤销，git diff没有任何内容了。

一对反义词
git add .的反义词是git checkout .。做完修改之后，如果你想向前走一步，让修改进入暂存区，就执行git add .，如果你想向后退一步，撤销刚才的修改，就执行git checkout .。

已暂存，未提交

你已经执行了git add .，但还没有执行git commit -m “comment”。这时候你意识到了错误，想要撤销，你可以执行：

git reset
git checkout .

或者

git reset --hard

git reset只是把修改退回到了git add .之前的状态，也就是说文件本身还处于已修改未暂存状态，你如果想退回未修改状态，还需要执行git checkout .。

或许你已经注意到了，以上两个步骤都可以用同一个命令git reset --hard来完成。是的，就是这个强大的命令，可以一步到位地把你的修改完全恢复到未修改的状态。

已提交，未推送

你的手太快，你既执行了git add .，又执行了git commit，这时候你的代码已经进入了你的本地仓库，然而你后悔了，怎么办？不要着急，还有办法。

git reset --hard origin/master

还是这个git reset --hard命令，只不过这次多了一个参数origin/master，正如我们上面讲过的，origin/master代表远程仓库，既然你已经污染了你的本地仓库，那么就从远程仓库把代码取回来吧。

已推送

很不幸，你的手实在是太快了，你既git add了，又git commit了，并且还git push了，这时你的代码已经进入远程仓库。如果你想恢复的话，还好，由于你的本地仓库和远程仓库是等价的，你只需要先恢复本地仓库，再强制push到远程仓库就好了：

git reset --hard HEAD^
git push -f

总结

以上4种状态的撤销我们都用到了同一个命令git reset --hard，前2种状态的用法甚至完全一样，所以只要掌握了git reset --hard这个命令的用法，从此你再也不用担心提交错误了。

以上内容转载于

https://segmentfault.com/a/1190000011969554

如提示无法安全下载请选择 保留 - 依然保留

服务器：mcserver.shimmerl.top

服务端版本为1.16.5请确认您电脑中有Java11及以上版本的运行环境

Java下载地址：https://www.oracle.com/java/technologies/downloads/

如无法正常进入甲骨文官网下载的Java可以去我的 下载站(点击跳转) 内 选择 抓包/环境 找到Java JDK 17然后选择相应的系统版本下载即可

小木斧命令

//limit <參數>	設置一個修改的最大數量方塊(個)。
歷史紀錄
//undo	復原最後一個動作。
//redo	還原復原的動作。
/clearhistory	清除歷史紀錄。
選取區
//sel <形狀>	選擇區域的形狀。形狀有：長方形(cuboid) 橢圓形(ellipsoid) 圓形(sphere)
//pos1	選取所站的位置的方塊。(選取點A)
//pos2	選取所站的位置的方塊。(選取點B)
//hpos1	顯示你所選取的點。(選取點A)
//hpos2	顯示你所選取的點。(選取點B)
//expand	擴大垂直範圍到天空&基石。
//size	選取區大小
//count <方塊ID>	計算選取區內該方塊的數量。
//distr	選區取內各方塊的分布。
修改選取區
//set<方塊ID>	讓選取區內都變為該方塊。(0為空氣=移除所有方塊)
//replace <A方塊ID> <B方塊ID>	以B方塊替換所有的A方塊。
//overlay <方塊ID>	在選取區頂部放置該方塊。
//walls <方塊ID>	在選取區內建立牆壁。(圍住選取區內部四周)
//outline <方塊ID>	在選區取內建立牆壁.天花板.地板。
//regen	重新選擇區域。
//move <移動格數> <方向> <不移動方塊ID>	
把選取區內方塊移動位置
(移動格數：請填要移動的格數
方塊：可不填，但要面向要移動的方向
不移動方塊ID：可不填)
//stack <格數> <方向(可不填)>	向該方向延伸選區區內的方塊
剪貼板
//copy	複製
//cut	剪下
//paste	貼上
//rotate	旋轉90.180.240.360度(必須先複製旋轉完在貼上)
//flip	翻轉(必須先複製翻轉完在貼上)※面向的方向為翻轉的方向
/clearclipboard	清除剪貼板
創建
/ / hcyl <方塊ID> <半徑> <高>
創建一個垂直的空心圓柱。
//cyl <方塊ID> <半徑> <高>	創建一個垂直的實心圓柱。
//sphere<方塊ID> <半徑>	創建一個實心球體。
/ / hsphere	創建一個空心的球體
/forestgen <大小> <類型> <密度>	創建森林。(不用選區而是以你為中心)
/pumpkins <大小>	創建南瓜森林。(不用選區而是以你為中心)
其他(不用選區而是以你為中心)
//fill <方塊UD> <半徑> <深度>	填一個洞。
//drain <半徑>	移除半徑內的水/岩漿，
/fixwater <半徑>	整流水/岩漿(讓它不會有亂流)。
/removeabove <大小> <高度>	刪除你以上的方塊
/removebelow <大小> <高度>	刪除你以下的方塊
/snow <半徑>	模擬降雪
/thaw <半徑>	解凍
/remove snow. <半徑>	清除雪
//ex <半徑>	滅火
/butcher <半徑>	殺死附近的怪物
/remove <物品名稱>	
刪除附近的實體物。(箭arrows 船arrows 礦車minecarts 點燃的TNT tnt)
//worldedit version	查看插件版本
//worldedit reload	重讀插件

server.properties规则如下

#Minecraft server properties
#Mon Apr 25 14:26:13 CST 2022
allow-flight=true
allow-nether=false
broadcast-console-to-ops=true
broadcast-rcon-to-ops=true
difficulty=peaceful
enable-command-block=false
enable-jmx-monitoring=false
enable-query=false
enable-rcon=false
enable-status=true
enforce-whitelist=false
entity-broadcast-range-percentage=100
force-gamemode=true
function-permission-level=2
gamemode=creative
generate-structures=true
generator-settings={}
hardcore=false
hide-online-players=false
level-name=Light
level-seed=
level-type=default
max-build-height=256
max-players=914
max-tick-time=60000
max-world-size=29999984
motd=\u6B22\u8FCE\u6765\u5230Shimmer MC Server\n\u00A7l\u00A73v0.8.5
network-compression-threshold=256
online-mode=false
op-permission-level=4
player-idle-timeout=0
prevent-proxy-connections=true
pvp=false
query.port=25565
rate-limit=0
rcon.password=
rcon.port=25575
require-resource-pack=false
resource-pack=
resource-pack-prompt=
resource-pack-sha1=
server-ip=
server-port=25565
simulation-distance=10
snooper-enabled=true
spawn-animals=true
spawn-monsters=true
spawn-npcs=true
spawn-protection=0
sync-chunk-writes=true
text-filtering-config=
use-native-transport=true
view-distance=10
white-list=false

除了文档规则以外为了保证服务器稳定运行请自觉遵守以下规则
虽然不禁止红石但请自觉遵守

1. 禁止种地
2. 禁止服中使用高频红石炸服
3. 禁止使用命令方块炸服
4. 创世神请谨慎使用，如果选区过大建议分批使用以防导致服务器无响应
5. 别在出生前面的大平地建东西了 那里准备放世界树
6. 禁止使用创世神导入超大形建筑

域名故障文档

1. 请先确认自己有公网IPv6地址，可点击下列地址查看自己是否有公网IP v6地址
   https://test-ipv6.com/index.html.zh_CN

Mods列表

补充Mods

可自由选择是否添加以下模组

把模组下载到本地之后把它复制到.minecraft目录下的 mods文件夹即可

Xaero的迷你地图：http://xz.shimmerls.top/mc/Xaeros_Minimap_22.6.0_Forge_1.16.5.jar

以前看过一个视频：女生挑战恶搞男朋友女生在半夜四点把一点半左右才睡的男生叫起来让做早饭，男生不是很愿意，但还是下了一碗面还加了一个煎蛋。

女生就开始了作妖了，不停的撒泼打滚，让男朋友去离家一公里左右的地方买肠粉。当时差不多才四点半。男生很无奈，哄着说。咱们先将就一下吧，等天亮了去买，现在太早了。

女生不情愿说着 我就要吃这个，你不爱我了，你没买到你就别回了就分手！！

男生当时就一下子怒气上头了，把面往桌子上一扔，没带钥匙没带手机，摔门走了

你在逗我吗？谁会凌晨4，5点让男盆友出门离家一公里多买早餐啊？

是我早就给你两锭子，一耳屎给你飞过来。你还在哪儿说诶呀，怎么办呀后来六点多的时候她男朋友把早餐买回来了，还哄着她乖乖，不好意思，起床气太严重了，凶了你女生还说你难道没看出来我在拍恶搞视频吗，哈哈哈哈哈哈哈哈哈哈你好傻呀哈哈哈哈视频最后，两个人甜甜美美的把早餐分来吃了（女生吃了一口肠粉，谢谢亲爱的，好好吃啊，然后就没动了，吃的是那碗面，男生把剩的肠粉吃完了）

我就觉得天啊，什么人啊，但是评论全部是好幸福啊，这才是爱情啊。

我也就不多说什么了，现在突然发现这不是我的三观出现了偏差，而是这些人带坏了年轻一代的三观。

无论是恋爱还是结婚，都应该是两个独立的个体，在结合后更好的生活在一起，产生1+1大于或等于2的效应。

抖音上有很多人发一些被自己另一半宠成女儿的视频。说真的，这种捧杀着实让人恐惧。

如果女孩子有正确的三观，有远见，有思想，这种宠爱可以算是两人相处中的小情趣。如果女孩子没有正确的三观，又长期在另一半的甜言蜜语、过分宠溺下生活，久而久之会失去独立生活的能力。一旦对方选择离开，后果不堪设想。试想，如果被另一半宠的既没工作，又没有自理能力。等到哪一天对方厌倦了，不再哄着你玩了，一气之下分开。突然发现，自己什么都不会了，那才是真的为时已晚啊。

而真正良性的关系是，鼓励另一半创造属于自己的价值，变得更有思想，更有远见。 即使目前生活美好，仍然不会安于现状，共同学习，为生活增添更多的筹码，以便一同应对未来生活中的种种考验。这种感情才更坚实，不容易被小问题给冲散。

那些希望被宠上天的对象，在我看来就是一种非常极其自私的表现。

谁不是爸妈一把屎一把尿拉扯大的？凭什么要让别人伺候你。

相互理解，相互尊重，相互成长才是婚姻幸福的样子。刷抖音不要太认真，当笑话看看就行了。别人拿抖音当做赚钱的工具，我们就别傻呼呼的把里面的道理当成过日子的真谛了。

你可以忙自己的事情，工作学习甚至是和朋友包宿玩耍，不用秒回我消息，哪怕你过很久再回都没关系，我看到什么想和你分享的事情依旧会发给你，因为我清楚的知道你忙完你的事或有空的时候一定会看到我的消息，一定会回复我。何况每个人都有自己的生活，虽然都是手机不离身但是没有人是二十四小时都等着你的信息的，我自己做不到时刻秒回。

在我看来我不会给我的对象在什么520，什么情人节，什么秋天的第一杯奶茶，什么冬天的十根热狗，这些时间里过多的消费，这些在我眼里这只是商家这些年来的营销手段罢了，但这不代表我不会这些仪式感，你只要平常出门看到什么觉得你会喜欢的东西，我欣喜的买下带回来给你，这种仪式感才是最真实的，而不是把仪式感都用在了数字上，然后为发朋友圈而发朋友圈，为秀而秀，为仪式感而仪式感。在我看来真正有意义的仪式感是为了他开心，而不是为了子虚乌有人为规定的数字。有人为了这种“浪漫”而大吵一架，甚至分手，真的没必要，评论区有人说的一句话非常对：可以浪漫，但不要被浪漫道德绑架。何况，人为的去规定的浪漫，它还浪漫么？

以上是我愚味的个人观点，如与你的观念不符的，你可以保留你的， 我也保留我的。

" 谈恋爱时，你会让男朋友为你花钱吗？ "

这是一个刚谈恋爱的朋友，随口问我的一句话。

他们感情还在磨合期 " 吃饭需不需要AA？ " 、 " 收到礼物用不用再送回去？ " 等一系列涉及金钱的问题都让朋友头疼不已。

不AA的话觉得对方很吃亏，AA的话又怕对方觉得自己见外。

总之，无论怎么选择，都很难两全其美。

我之前谈恋爱的时候，也遇到过同样的问题。

那还是在大学的时候，我们都还是学生，尚未出社会自己挣钱，手头也并不宽裕，每个月都要靠父母转来的1500块生活，所以，每次一起出去玩都要 " 分摊 " 。

但这种分摊，并不代表每一顿饭、每一瓶水都必须要对半分，而是两个人之间有来有往，你请我这顿、我请你下顿。

平时如果男生请我吃饭，我就会主动去买电影票和奶茶，如果我给他买了礼物，他也会在心里自觉记下 " 账本 " ，不久之后也会惦记着给我买上一份。

因为恋爱本来就是两个人的事，生活费用就应该两个人共同承担。

所以，那个时候，虽然没有什么物质基础，但是我们从来没有为钱争吵过，也没有计较过谁付出的多，谁付出的少。

两个相爱的人在一起，相比于物质更重要的是爱的感觉。

我们不会在几十块钱的饭菜账单上，平分你我，保全自身利益，也不会抱着你不占我便宜、我也不占你便宜的心态相处。

谈钱并不是一件尴尬的事，而是我们之间的自觉和默契。

可话说回来，如果AA制延续到了婚姻生活中，精准到了柴米油盐的划分中，那或许就失去了婚姻的意义，显得太过冰冷。

综艺《朋友请听好》中有一个故事，月薪3500的女孩与月薪10000的男孩相亲认识后，被男方父母要求 " 婚后AA " 。

因为考虑到女方薪水没有男方多，所以男方家里要求女方承担全部家务，男方每个月会给女方4000块用于日常生活，超出部分就平摊，两个人在婚后也要 " 经济独立 " 。

**听完这个故事，在场所有人的脸色都不太好，何炅很直接地说， " 两个人在一起要是这么算计的话，真不如算了！ " **

男方一家的做法看似公平，实则是找了一个免费保姆，而且女孩在怀孕生孩子期间，没有收入根本没法做到AA。

虽然婚姻中谈钱并不是一件敏感话题，AA制婚姻也有它存在的合理性，但如果不懂变通，一味强调金钱的平衡而不考虑对方的感受，就很容易伤害到夫妻双方的感情，A着A着感情就散了。

我们常说，婚姻是两个人的相互支撑和齐头并进，它是你帮我一把的交情，也是我扶你一下的义气。

既然两个人决定迈进婚姻里，就该为彼此提供一份依靠。

这是相互的，也是基本的。

不可否认， " AA制 " 在某种程度上会让感情变得简单一些，让双方的相处也不会有太大经济压力，但它并不是让感情降至冰点的速冻剂。

两个人在一起要不要AA制，其实很难给出一个标准答案，毕竟每段感情都各有不同，但公平、尊重是必须考量的前提，而不是一味尊崇某种 " 约定 " 。

**我想起来陈妍希在综艺《因为是朋友呀》中说过的一句话， " 在感情中，如果对方经济条件没有那么高，可能就更需要相互配合，毕竟感情是两个人的事。 " **

虽然钱数可以算得清楚，感情却是无价的。

两个人在一起追求的一定是幸福加倍，而不是金钱平衡。

无论再独立坚强的人，都想要一份1＋1大于2的感情，而不是遇见真爱后依然苦苦支撑。

而且恋爱本身就不是一种投资，所以就不要太过于计较回报。

无论两个人感情到了什么程度，都不要让金钱成为生活的唯一衡量标准。

Typecho 在用户评论时会记录其访问 ip 地址。

不过开启 CDN 之后，经常记录下来的就是 CDN 的代理 IP 了，后台评论看到了很多一样的IP地址

后来才发现是 CDN 的 IP，差点就删除了这些评论了，那么如何解决 Typecho 使用 CDN 后不显示访客真实 IP 地址呢？

解决方法

在Typecho站点根目录里找到 config.inc.php 文件 添加下面这段代码：

/**使用CDN后获取访客真实ip*/
if(isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
  $list = explode(',',$_SERVER['HTTP_X_FORWARDED_FOR']);
  $_SERVER['REMOTE_ADDR'] = $list[0];
}

保存之后就可以获取到用户真实的IP了

花店不是为了花而开的，但我是为了你而来的。

万里星光，一如既往。

生命可以随心所欲，但不能随波逐流。

一个人至少拥有一个梦想，有一个理由坚强，心若没有栖息的地方，到哪里都是流浪。——梦想

鸡蛋从外面打破是食物，从内部打破是生命。人从外打破是压力，从内打破是成长。——成长

我对自己说，跨过去，春天不远了，永远不要失去发芽的心情。——直面困难
昨日之时，你教我草长莺飞，细雨朦胧；今日之时，我教你细数花名，测天看云。——感恩

虽然绿灯没怎么为我亮过，但我还是对生活充满热情，这就是我理解的年轻。——青春

我们生活在24小时不眠不休的社会里，但并没有24小时不眠不休的身体，有些东西必须舍弃。——取舍

重要的人越来越少，剩下的人也越来越重要。——情感，感恩

也许大海给贝壳下的定义是珍珠，也许时间给煤炭下的定义是钻石。——拼搏

最长的路也有尽头，最黑暗的夜晚也会迎接清晨。——坚持

树林在森林中相依偎而生长，星辰在银河中因辉映而璀璨。——团结

没有磨砺的灵魂没有深度，没有风暴的海洋是池塘。——勇敢无畏

不是所有坚持都会有结果，但总有一些坚持，能从一寸冰封的土地里培育出十万朵怒放的蔷薇。——坚持

《六国论》

原文

　　六国破灭，非兵不利，战不善，弊在赂秦。赂秦而力亏，破灭之道也。或曰：“六国互丧，率赂秦耶？”曰：“不赂者以赂者丧，盖失强援，不能独完。故曰弊在赂秦也。”

　　秦以攻取之外，小则获邑，大则得城。较秦之所得与战胜而得者，其实百倍；诸侯之所亡与战败而亡者，其实亦百倍。则秦之所大欲，诸侯之所大患，固不在战矣。

　　思厥先祖父，暴霜露，斩荆棘，以有尺寸之地。子孙视之不甚惜，举以予人，如弃草芥。今日割五城，明日割十城，然后得一夕安寝。起视四境，而秦兵又至矣。然则诸侯之地有限，暴秦之欲无厌，奉之弥繁，侵之愈急。故不战而强弱胜负已判矣。至于颠覆，理固宜然。古人云：“以地事秦，犹抱薪救火，薪不尽，火不灭。”此言得之。

　　齐人未尝赂秦，终继五国迁灭，何哉？与嬴而不助五国也。五国既丧，齐亦不免矣。燕、赵之君，始有远略，能守其土，义不赂秦。是故燕虽小国而后亡，斯用兵之效也。至丹以荆卿为计，始速祸焉。赵尝五战于秦，二败而三胜。后秦击赵者 再，李牧连却之。洎牧以谗诛，邯郸为郡，惜其用武而不终也。且燕、赵处秦革灭殆尽之际，可谓智力孤危，战败而亡，诚不得已。向使三国各爱其地，齐人勿附于秦，刺客不行，良将犹在，则胜负之数，存亡之理，当与秦相较，或未易量。
　　
呜呼！以赂秦之地封天下之谋臣，以事秦之心礼天下之奇才，并力西向，则吾恐秦人食之不得下咽也。悲夫！有如此之势，而为秦人积威之所劫，日削月割，以趋于亡。为国者无使为积威之所劫哉！夫六国与秦皆诸侯，其势弱于秦，而犹有可以不赂而胜之之势。苟以天下之大，而从六国破亡之故事，是又在六国下矣。

译文

　　六国的灭亡，不是（因为他们的）武器不锋利，仗打得不好，弊端在于用土地来贿赂秦国。拿土地贿赂秦国亏损了自己的力量，（这就）是灭亡的原因。有人问：“六国一个接一个的灭亡，难道全部是因为贿赂秦国吗？”（回答）说：“不贿赂秦国的国家因为有贿赂秦国的国家而灭亡。原因是不贿赂秦国的国家失掉了强有力的外援，不能独自保全。所以说：弊病在于贿赂秦国。”

　　秦国除了用战争夺取土地以外，（还受到诸侯的贿赂），小的就获得邑镇，大的就获得城池。比较秦国受贿赂所得到的土地与战胜别国所得到的土地，(前者)实际多百倍。六国诸侯（贿赂秦国）所丧失的土地与战败所丧失的土地相比，实际也要多百倍。那么秦国最想要的，与六国诸侯最担心的，本来就不在于战争。想到他们的祖辈和父辈，冒着寒霜雨露，披荆斩棘，才有了很少的一点土地。子孙对那些土地却不很爱惜，全都拿来送给别人，就像扔掉小草一样不珍惜。今天割掉五座城，明天割掉十座城，这才能睡一夜安稳觉。明天起床一看四周边境，秦国的军队又来了。既然这样，那么诸侯的土地有限，强暴的秦国的欲望永远不会满足，（诸侯）送给他的越多，他侵犯得就越急迫。所以用不着战争，谁强谁弱，谁胜谁负就已经决定了。到了覆灭的地步,道理本来就是这样子的。古人说：“用土地侍奉秦国，就好像抱柴救火，柴不烧完，火就不会灭。”这话说的很正确。

　　齐国不曾贿赂秦国，（可是）最终也随着五国灭亡了，为什么呢？（是因为齐国）跟秦国交好而不帮助其他五国。五国已经灭亡了，齐国也就没法幸免了。燕国和赵国的国君，起初有长远的谋略，能够守住他们的国土，坚持正义，不贿赂秦国。因此燕虽然是个小国，却后来才灭亡，这就是用兵抗秦的效果。等到后来燕太子丹用派遣荆轲刺杀秦王作对付秦国的计策，这才招致了（灭亡的）祸患。赵国曾经与秦国交战五次，打了两次败仗，三次胜仗。后来秦国两次攻打赵国。（赵国大将）李牧接连打退秦国的进攻。等到李牧因受诬陷而被杀死，（赵国都城）邯郸变成（秦国的一个）郡，可惜赵国用武力抗秦而没能坚持到底。而且燕赵两国正处在秦国把其他国家快要消灭干净的时候，可以说是智谋穷竭，国势孤立危急，战败了而亡国，确实是不得已的事。假使韩、魏、楚三国都爱惜他们的国土，齐国不依附秦国。（燕国的）刺客不去（刺秦王）（赵国的）良将李牧还活着，那么胜败的命运，存亡的理数，倘若与秦国相比较，也许还不容易衡量（出高低来）呢。

　　唉！（如果六国诸侯）用贿赂秦国的土地来封给天下的谋臣，用侍奉秦国的心来礼遇天下的奇才，齐心合力地向西（对付秦国），那么，我恐怕秦国人饭也不能咽下去。真可悲啊！有这样的有利形势，却被秦国积久的威势所胁迫，每日每月割让土地，以至于走向灭亡。治理国家的人不要被积久的威势所胁迫啊！

　　六国和秦国都是诸侯之国，他们的势力比秦国弱，却还有可以不贿赂秦国而战胜它的优势。如果凭借偌大国家，却追随六国灭亡的前例，这就比不上六国了。

注释

1. 兵：兵器
2. 善：好。
3. 弊在赂秦：弊病在于贿赂秦国。赂，贿赂。这里指向秦割地求和。
4. 或曰：有人说。这是设问。下句的“曰”是对该设问的回答。
5. 率：都，皆。
6. 盖：承接上文，表示原因，有“因为”的意思。
7. 完：保全。
8. 攻取：用攻战（的办法）而夺取。
9. 小：形容词作名词，小的地方。
10. 其实：它的实际数目。
11. 所大欲：所最想要的（东西），大，最。
12. 厥先祖父：泛指他们的先人祖辈，指列国的先公先王。厥，其。先，对去世的尊长的敬称。祖父，祖辈与父辈.
13. 暴霜露：暴露在霜露之中。意思是冒着霜露。和下文的斩荆棘，以有尺寸之地，都是形容创业的艰苦。
14. 视：对待
15. 举以予人：拿它（土地）来送给别人。实际是举之以予人，省略了之，代土地。
16. 然则：既然这样，那么。
17. 厌：同“餍”，满足。
18. 奉之弥繁，侵之愈急：（诸侯）送给秦的土地越多，（秦国）侵略诸侯也越急。奉：奉送。弥、愈：都是“更加”的意思。繁：多。
19. 判：决定。
20. 至于：以至于。
21. 颠覆：灭亡。
22. 理固宜然：（按照）道理本来就应该这样。
23. 事：侍奉。“以地事秦……火不灭”：语见《史记魏世家》和《战国策魏策》。
24. 此言得之：这话对了。得之，得其理。之，指上面说的道理。
25. 终：最后。
26. 继：跟着。
27. 迁灭：灭亡。古代灭人国家，同时迁其国宝、重器，故说“迁灭”。
28. 与嬴：亲附秦国。与，亲附。嬴，秦王族的姓，此借指秦国。
29. 既：已经。
30. 免：幸免。
31. 始有远略：起初有长远的谋略。
32. 义：名词作动词，坚持正义。
33. 斯：这
34. 始：才
35. 速：招致。
36. 再：两次。
    37．连却之：使...退却（动词的使动用法）
    38．洎：及，等到。
37. 以：因为。谗：小人的坏话。
38. 邯郸为郡：秦灭赵之后，把赵国改为秦国的邯郸郡。邯郸，赵国的都城。
39. 且燕、赵处秦革灭殆尽之际：燕赵两国正处在秦国把其他国家快要消灭干净的时候。革,改变，除去。殆，几乎，将要。
    42． 智力：智谋和力量（国力）。
40. 向使：以前假如。
41. 胜负之数，存亡之理：胜负存亡的命运。数，天数。理，理数。皆指命运。
42. 当：同“倘”，如果。
43. 易量：容易判断。
44. 以赂秦之地封天下之谋臣：以，用。
45. 礼：礼待。名作动。
46. 食之不得下咽也：指寝食不安，内心惶恐。下：向下，名作动。咽：吞咽。
47. 势：优势。
48. 而为秦人积威之所劫：而，却。积威：积久而成的威势。劫，胁迫，劫持。
49. 日削月割，以趋于亡：日，每天，名作状。月，每月，名作状。以，而。
50. 为国者无使为积威之所劫哉：治理国家的人不要被积久的威势胁迫啊！
51. 势弱于秦。于：比。
52. 而犹有可以不赂而胜之之势。可以：可以凭借。
53. 苟以天下之大：苟，如果。以，凭着。
54. 从：跟随。
55. 故事：旧事，先例。
56. 下：降低身份。

文言知识

一、文言实词

1．通假字 

(1)暴霜露(暴：通“曝”，曝露) 
(2)当与秦相较，或未易量(当：通“倘”，倘若)
(3)暴秦之欲无厌(厌：通“餍”，满足)

2．古今异义 

(1)与战胜而得者，（其实）百倍
古义：它实际上的数量 ；今义：实际上

(2)思厥先（祖父）
古义：祖辈和父辈；今义：父亲的父亲

(3)（至于）颠覆，理固宜然
古义：引出结果。以至于。 今义：连词，表示到达某种程度

(4)可谓（智力）孤危
古义：智谋和力量。 今义：理解事物的能力

(5)下而从六国破亡之（故事）
 古义：先例，旧事 。今义：真实的或虚构的有关人物的事情

(6)后秦击赵者（再）
 古义：两次 。今义：又，又一次

(7)（然后）得一夕安寝
古义：这样以后 。今义：表示一件事情之后接着又发生另一件事情

(8)刺客（不行）
古义：不去行刺。今义：能力、本事欠缺；水平不高

(9)则吾恐秦人食之不得（下咽）也
古：咽下咽喉 ；今：吞咽

(10)始（速）祸焉
古义：招致。今义：速度 
 

3．词类活用

(1) 名词作状语。 
日削月割　（日：一天天地；月：一月月地）
至于颠覆，理固宜然　（理：按理来说）
并力西向（西，向西。）

(2) 名词作动词。
义不赂秦　（义：坚持正义） 
以事秦之心礼天下之奇才　（礼：礼待）
则吾恐秦人食之不得下咽也　（下：吞下）
以地事秦　（事：侍奉）

(3) 形容词作动词。
不能独完　(完：保全) 
惜其用武而不终也　（终：坚持到最终）
始速祸焉　（速：招致）

(4)动词的使动用法： 
李牧连却之 （却：使…退却，译为打退 ）

4．一词多义 

(1)兵
非兵不利　（名词，兵器、武器） 
而秦兵又至矣　（名词，军队）
斯用兵之效也　（名词，武力） 

(2)事
以地事秦　（动词，侍奉） 
而从六国破亡之故事　(名词，事情) 

(2)犹
犹抱薪救火　（动词，像，好象） 
犹有可以不赂而胜之之势　(副词，仍然，还) 

(4)终
终继五国迁灭　（副词，终于） 
惜其用武而不终也　(动词，坚持到最终) 

(5)始 
始有远略　（名词，起初） 
始速祸焉　(副词，才) 

(6)向
向使三国各爱其地　(副词，假使，如果) 
并力西向　(动词，朝着，对着) 

(7)得 
较秦之所得　(动词,获得) 
此言得之　(动词,适合,得当) 

(8)势 
有如此之势　 (优势) 
其势弱于秦　 (势力) 

(9)亡
诸侯之所亡，与战败而亡者　（失去土地） 
是故燕虽小国而后亡　（灭亡） 

二、文言虚词 

1．而 

(1) 连词，表承接。
而犹有可以不赂而胜之之势／赂秦而力亏／战败而亡

(2) 连词，表修饰。
较秦之所得与战胜而得者

(3) 连词，表转折。
而秦兵又至矣／与嬴而不助五国也／惜其用武而不终也／而为秦人积威之所劫／而犹有可以不赂而胜之之势 

(4) 连词，表并列。
二败而三胜 

2．之 

(1) 结构助词，的。 
破灭之道也／较秦之所得／诸侯之所亡

(2) 定语后置的标志。
苟以天下之大

(3) 代词。 
子孙视之不甚惜(指土地) 
奉之弥繁，侵之愈急(代词，前一个代“秦”，后一个代“贿赂的诸侯”) 
此言得之(指上文说的道理) 
而犹有可以不赂而胜之之势(前一个代指“秦”；后一个助词，的)
其实亦百倍(指获得的土地) 
惜其用武而不终也(指赵国) 
其势弱于秦(指六国)

3．则 

(1) 连词，就。   小则获邑，大则得城
(2) 连词，那么。   则秦国之所大欲

4．与 

(1) 动词。亲附、亲近 　与赢而不助五国也 
(2) 介词，跟，同，表比较的对象。　与战胜而得者 
(3) 连词，和，同，表并列。　六国与秦皆诸侯 

三、文言句式

1．判断句 

(1)是故燕虽小国而后亡，斯用兵之效也（用“也”表判断）
(2)赂秦而力亏，破灭之道也(用“也”表判断)

2．省略句 

(1)举(之)以(之)予人(省宾语“之”和介词宾语“之”)
(2)(子孙)起视四境，而秦兵又至矣(省主语“子孙”)
(3)洎牧以谗诛，邯郸为(秦)郡(省定语“秦”，秦国的)

3．变式句 

(1)其势弱于秦(于秦弱，介宾后置)
(2)赵尝五战于秦(于秦五战，介宾后置)
(3)苟以天下之大(大天下，定语后置)

4．被动句 

(1)有如此之势，而为秦人积威之所劫(为…所，表被动)
(2)为国者无使为积威之所劫哉(为…所，表被动) 

四、成语 

如弃草芥：芥，小草。就像扔掉一根小草那样。形容毫不在意。 
抱薪救火：薪：柴草。抱着柴草去救火。比喻用错的方法去消除灾祸，结果使灾祸反而扩大。

写作特点

1. 借古讽今，针砭时弊
   战国时代，七雄争霸。为了独占天下，各国之间不断进行战争。最后六国被秦国逐个击破而灭亡了。六国灭亡的原因是多方面的，其根本原因是秦国经过商秧变法的彻底改革，确立了先进的生产关系，经济得到较快的发展，军事实力超过了六国。同时，秦灭六国，顺应了当时历史发展走向统一的大势，有其历史的必然性。本文属于史论，但并不是进行史学的分析，也不是就历史谈历史，而是借史立论，以古鉴今，选择一个角度，抓住一个问题，持之有故、言之成理地确立自己的论点，进行深入论证，以阐明自己对现实政治的主张。因此我们分析这篇文章，不是看它是否准确、全面地评价了历史事实，而应着眼于其强烈的现实针对性。本文从历史与现实结合的角度，依据史实，抓住六国破灭“弊在赂秦”这一点来立论，针砭时弊，切中要害，表明了作者明达而深湛的政治见解。文末巧妙地联系北宋现实，点出全文的主旨，语意深切，发人深省。

2. 论点鲜明，论证严密
   本文为论说文，其结构完美地体现了论证的一般方法和规则，堪称古代论说文的典范。文章开篇即提出六国破灭“弊在赂秦”的论点；然后以史实为据，分别就“赂秦”与“未尝赂秦”两类国家从正面加以论证；又以假设进一步申说，如果不赂秦则六国不至于灭亡，从反面加以论证；从而得出“为国者无使为积威之所劫”的论断；最后借古论今，讽谏北宋统治者切勿“从六国破亡之故事”。文章围绕中心论点展开论证，既深入又充分，逻辑严密，无懈可击。全文纲目分明，脉胳清晰，结构严整。不仅句与句、段与段之间有紧密的逻辑联系，而且首尾照应，古今相映。文中运用例证、引证、假设，特别是对比的论证方法。如“赂者”与“不赂者”对比；秦与诸侯双方土地得失对比，既以秦受赂所得与战胜所得对比，又以诸侯行赂所亡与战败所亡对比；赂秦之频与“一夕安寝”对比；以六国与北宋对比。通过对比增强了“弊在赂秦”这一论点的鲜明性、深刻性。

3. 语言生动，气势充沛
   在语言方面，本文除了具有一般论说文用词准确、言简意赅的特点之外，还有语言生动形象的特点。在论证中穿插“思厥先祖父……而秦兵又至矣”的描述，引古人之言来形象地说明道理，用“食之不得下咽”形容“秦人”的惶恐不安，大大增强了文章的表达效果。文章的字里行间饱含着作者的感情。不仅有“呜呼”“悲夫”等感情强烈的嗟叹，就是在夹叙夹议的文字中，也流溢着作者的情感，如对以地事秦的憎恶，对“义不赂秦”的赞赏，对“用武而不终”的惋惜，对为国者“为积威之所劫”痛惜、激愤，都溢于言表，有着强烈的感染力，使文章不仅以理服人，而且以情感人。再加上对偶、对比、比喻、引用、设问等修辞方式的运用，使文章“博辨以昭”（欧阳修语），不仅章法严谨，而且富于变化，承转灵活，纵横恣肆，起伏跌宕，雄奇遒劲，具有雄辩的力量和充沛的气势。

赏析：

六国被秦国灭亡的教训，是许多文史家关注的话题。仅“三苏”就每人写了一篇《六国论》。苏轼的《六国论》，针对六国久存而秦速亡的对比分析，突出强调了“士”的作用。苏轼认为，六国诸侯卿相皆争养士，是久存的原因。只要把那些“士”养起来，老百姓想造反也找不到带头人了，国家就可以安定了。苏辙的《六国论》则是针对六国不免于灭亡的史实，指出他们相继灭亡的原因是不能团结一致，共同抗战，灭国是咎由自取。

苏洵的《六国论》不同于以上两篇。苏洵不是就事论事，而是借题发挥。苏洵的写作目的不在于总结六国灭亡的教训，而在于警告宋朝统治者勿蹈六国灭亡的覆辙。借古喻今，以谈论历史供当今统治者借鉴，这是苏洵高出其二子的地方。从历史情况看，六国灭亡的原因并不是“赂秦”。六国的失败，主要是政治上保守，因循守旧，不重视改革，不能坚持“合纵”政策去对付秦国的“连横”政策，被秦国远交近攻的手段各个击破。另一方面，秦孝公任用商鞅变法，使秦国国力大增，具备了统一中国的实力。加上战国长期的战乱，民不聊生，由分裂到统一，符合人们的愿望。秦国统一中国，是历史发展的必然趋势。苏洵对此并非不知，他在文中也承认这一点：“以赂秦之地，封天下之谋臣；以事秦之心，礼天下之奇才，并力西向，则吾恐秦人食之不得下咽也。”然而作者用意不在此，他的意图是点明赂秦是六国灭亡的原因，以此警告宋朝统治者，不要用贿赂的方法对待契丹和西夏，要用武力，要抵抗。明代何仲默说过：“老泉论六国赂秦，其实借论宋赂契丹之事，而卒以此亡，可谓深谋先见之识矣。”

宋朝建国后，宋太祖片面地接受唐朝藩镇割据，尾大不掉，以至灭亡的教训，采取了“虚外实内”的政策，削弱边关的实力，调集重兵驻守京城。结果造成了边关的空虚。辽国乘虚而入，屡犯边疆。宋太宗继位后，曾两次派兵击辽，均遭失败。后宋太宗两次进攻幽州，企图夺回幽云十六州，又遭败绩。真宗景德元年（1004年），辽大兵压境，直逼澶州城下（今河南濮阳），威胁汴京开封。于是，宋与辽签定了“澶渊之盟”，答应向辽输岁币银十万两，绢二十万匹。到了仁宗庆历二年（1042年），辽再次要挟，宋只得增加币银十万两，绢十万匹。第二年（1043年），西夏也来要，又是赐岁币银十万两，绢十万匹，茶三万斤。人民的血汗就在这种纳赐之中，付之东流。苏洵对此痛心疾首，他借古喻今，纵横恣肆，痛陈利弊，对当权者进行规劝，希望其改弦易辙，增强国力，与敌斗争。苏洵的议论虽不无可商榷处，但总的立论是正确的，并且不幸为苏洵所言中：就在苏洵死后六十年，终于发生了“靖康之变”（1126年），北宋重蹈了六国的覆辙，为后起的金所灭，徽、钦二帝被俘，客死异国他乡。

《六国论》除去在立论上具有借题发挥、借古喻今的写作特点外，在论证的严密性、语言的生动性上也堪称典范。第一段的逻辑性是非常严密的。作者开篇亮出观点：“六国破灭，非兵不利，战不善，弊在赂秦。”开宗明义，直截了当，使读者一眼就抓住了论者的中心。然后，作者解释论点：“赂秦而力亏，破灭之道也。”这就指出了贿赂的危害，言简意赅，要言不烦。再后，作者设问：“六国互丧，率赂秦耶?”答曰：“不赂者以赂者丧。盖失强援，不能独完。”这就使得文章逻辑严密，无懈可击。最后一句总结全段：“故曰弊在赂秦也。”这一段起到了“纲”的作用，后面的二、三两段实际上是围绕第一段展开的。

本文的语言生动有力。议论性的句子简捷有力，叙述性的句子生动感人。比如：“思厥先祖父，暴霜露，斩荆棘，以有尺寸之地。子孙视之不甚惜，举以予人，如弃草芥。今日割五城，明日割十城，然后得一夕安寝。起视四境，而秦兵又至矣。”这些叙述语言本身带有主观感情，还有描述的特点。作者还运用引用、对比、比喻等手法，使语言灵活多样，增强了表达效果。本文的句式也整饬有度，特别是四字句占了一定比例，读起来铿锵有力，掷地有声，富有节奏感。文章史实论据典型、充分，分析、对比、比喻等论证具有很强的逻辑性和说服力，句式多变，感情激切，富有感染力。本文虽是史论，但作者本意不在于论证六国灭亡的原因，而在于引出历史教训，讽谏北宋王朝放弃妥协苟安的政策，警惕重蹈六国灭亡的覆辙。

欧阳修评价苏洵的文章说：“吾阅文士多矣，独喜尹师鲁、石守道，然意犹有所未足，今见子（苏洵）之文，吾意足矣。”的确如此，苏洵此文，奔腾上下，纵横出入，气势犹如江河决口。他见识深远，眼光犀利，议论精辟透彻，足警世人。无怪乎本文近千年来盛传不衰！

创作背景

《六国论》选自《嘉佑集》卷三。这是苏洵所写的《权书》中的一篇，《权书》共10篇，都是史论的性质。苏洵写这篇文章并不是单纯地评论古代的历史事件，而是借古讽今，警告北宋统治者不要采取妥协苟安的外交政策。

" 这个世界上，你会遇到很多给你买高跟鞋的男人，却再难碰到一个，给你吹鞋后跟的男人。 "

前两天闲在家里刷视频，无意间看到很感动的一幕：

一位女生下班回家后，累得瘫倒在沙发上，男友什么话都没说，去卧室里拿出一个小毯子悄悄给女生披上，然后把提前准备好的饭菜端到女生面前的桌子上。

随后又默默走到门前，蹲下来，拿起女生刚刚脱掉的高跟鞋，用吹风机，认真地吹去上面的灰尘。

镜头面前，女生熟睡的样子和男生认真擦鞋的样子，形成一副很舒服的画面。

虽然视频是无声的，但男生对女友的爱，就像能从镜头前溢出来一样，感动了很多人。

恋爱中的伴侣，从来不缺少说甜言蜜语的时刻，但那些真正的爱往往都藏在下意识的反应里。

前两天在地铁上目睹了一场不太愉快的吵闹，起因是一对情侣在上地铁的时候，女方被人撞了一下。

男生为了维护女友，一下子就恼火了，和对方吵了起来，要求对方向他女友道歉。

争吵过后，男生让女友站在另一侧，自己站在对方的旁边，把手别在扶手里暗暗较着劲。

期间女友一直劝和、打圆场，笑着让男生把手放下，但是男生依旧赌气死死抵挡在那里。

虽然男生的行为和言语，看起来有些好笑幼稚，但即便是旁观人，也能看得出来他是真心维护女友，不想让她受到一点冒犯和伤害。

就像有句话说： " 无心者教不会，有心者不用教。 "

真正的爱，从来不需要刻意学习，它细小又柔软，总是藏在下意识的眼神、动作和习惯里。

不需要你说很多、做很多，我就知道 " 你爱我 " 。

前几天在微博看到一位博主分享自己的恋爱故事：

她平时喜欢在朋友圈分享一些音乐，没想到第一次和喜欢的男生见面时，男生就在车上放了一首她很喜欢的歌。

起初她以为是巧合，但是没想到后来车一直开，音乐一首接一首，全是女生喜欢的歌。

她告诉对方： " 好巧啊，我们喜欢的歌都一样。 "

但是没有想到，男生回答她说： " 这些都是从你朋友圈拷贝过来的，我把它们弄成了一个歌单，这样开车的时候听就会想到你。 "

那一瞬间，她突然觉得特别感动。

因为曾经她也有过很多很多时刻，觉得再也不会相信爱情了，但是在这个男生身上，她看到了对方极其用心的浪漫，也重新找回了相信爱情的理由。

记得合租的室友也曾讲过，她恋爱三年的男友，直到如今都会将她分享的任何故事、风景、电影认认真真地看一遍。

等到闲暇的时候，再拿出来和她讨论其中有意思的地方。

甚至男生还有一个小习惯，会把她的朋友圈和微博的每一条动态都看完，把她喜欢的不喜欢的都记在备忘录里。

室友每次都能从男友的回应里，得到强烈的幸福感和踏实的安全感。

其实在一个真正爱你的人面前，你无需担心期待会落空，也不用怕分享得不到回应。

因为他会主动留意你的喜怒哀乐，在意你的很多小细节，如果你感觉不到，那或许就是没有。

有句话说： " 爱情可以有千万种模样，但没有一种可以藏得住爱本身。 "

真正被爱时，人是不会患得患失的，对方会将爱融在日常的点滴里、生活的细节中。

或许他也不善言辞，但他一定会用行动，证明自己的真心和诚意。

那个难过时耐心安抚你的人，那个困难时坚定保护你的人，那个总是能把你说过的话、做过的事都时刻记在心里的人，才是发自心底真正爱你的人。

他会在下雨天为你准备雨伞；感冒时为你准备一杯热水；下班时递过来一碗热汤；疲惫时给你一个依靠的肩膀；清晨时为你早起准备好豆浆油条。

这些看得见、摸得着的行动，都好过甜言蜜语、山盟海誓。

总有一天，你会知道，出自本能的爱，是装不出来，也藏不住的。

他所做的一切，都不是为了感动你，只是为了爱你。

学习js数据结构与算法 & 算法图解

栈

十进制转二进制

除2取余，直到整数为0，反向输出余数。

function divideBy2(num) {
    var stack = [],
        result = '';
    while(num > 0) {
        stack.push(Math.floor(num % 2));
        num = Math.floor(num / 2);
    }
    while(stack.length) {
        result += stack.pop().toString();
    }
    return result;
}

十进制转任意进制

function baseConverter(decNumber, base) {
    var stack = [],
        digits = '0123456789ABCDEF',
        result = '';
    while(decNumber > 0) {
        stack.push(Math.floor(decNumber % base));
        decNumber = Math.floor(decNumber / base);
    }
    while(stack.length) {
        result += digits[stack.pop()];
    }
    return result;
}

队列

循环队列

链表

• 单链表
• 双向链表
• 循环链表

集合

• 并集
• 交集
• 差集
• 子集

字典和散列表（HashMap）

散列表

选择散列函数

一个表现良好的散列函数是由几个方面构成的：插入和检索元素的时间（即性能），当然也包括较低的冲突可能性。

也有一些为数字键值准备的散列函数，你可以在找到一
系列的实现。

处理散列值冲突

处理冲突有几种方法：分离链接、线性探查和双散列法。

• 分离链接法 包括为散列表的每一个位置创建一个链表并将元素存储在里面。

• 线性探查 当想向表中某个位置加入一个新元素的时候，如果索引
  为index的位置已经被占据了，就尝试index+1的位置。如果index+1的位置也被占据了，就尝试
  index+2的位置，以此类推。

在一些编程语言中，我们需要定义数组的大小。如果使用线性探查的话，需
要注意的一个问题是数组的可用位置可能会被用完。在JavaScript中，我们不需
要担心这个问题，因为我们不需要定义数组的大小，它可以根据需要自动改变大
小——这是JavaScript内置的一个功能。

• 双散列法 即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。

树

基本术语

结点： 包含一个数据元素及若干指向子树的指针。

结点的度(Degree)： 结点拥有的子树数。

叶子(Leaf)（终端）结点： 度为零的结点。

分支（非终端）结点： 度大于零的结点。

树的度： 树内各结点度的最大值。

孩子(Child)： 结点的子树的根称为该结点的孩子。

双亲(Parent)： 该结点称为孩子的双亲。

兄弟(Sibling)： 同一双亲的孩子之间互称为兄弟。

祖先： 从根到该结点所经分支上的所有结点。

子孙： 以某结点为根的子树中的任一结点都称为该点的子孙。

层次： 从根开始定义，根为第一层，根的孩子为第二层，以此类推。

堂兄弟： 双亲在同一层的结点互为堂兄弟。

深度(Depth)： 树中结点的最大层次称为树的深度或高度。

有序树 & 无序树： 如果将树中结点的各子树看成从左至右是有序的，则称该树为有序树，否则为无序树。

森林(Forest)： m(m>=0)棵互不相交的树的集合。

二叉树(BinaryTree)： 每个结点至多只有两棵子树且左右有序。

二叉搜索树(BST)： 左边存储比父节点小，右边存储比父节点大的二叉树。

树的创建（BST）

function BST() {
    function Node(value) {
        this.value = value;
        this.left = null;
        this.right = null;
        this.parent = null;
    }
    this.root = null;
    this.addNode = function(value) {
        var node = new Node(value);
        if (this.root == null) {
            this.root = node;
        } else {
            var currentNode = this.root;
            var isContinue = true;
            while(isContinue) {
                if (value < currentNode.value) {
                    if (currentNode.left) {
                        currentNode = currentNode.left;
                    } else {
                        currentNode.left = node;
                        isContinue = false;
                    }
                } else if (value > currentNode.value) {
                    if (currentNode.right) {
                        currentNode = currentNode.right;
                    } else {
                        currentNode.right = node;
                        isContinue = false;
                    }
                }
            }
        }
    }
}

// 递归写法
function insertNode(root, newNode) {
    if (root === null) {
        root = newNode;
    } else {
        if (newNode.value < root.value) {
            if (root.left === null) {
                root.left = newNode;
            } else {
                insertNode(root.left, newNode);
            }
        } else {
            if (root.right === null) {
                root.right = newNode;
            } else {
                insertNode(root.right, newNode);
            }
        }
    }
}

树的遍历

中序遍历（左根右）

// 递归写法
function traveseTree(node, callback) {
    if (node !== null) {
        traveseTree(node.left, callback);
        callback(node);
        traveseTree(node.right, callback);
    }
}

// 非递归写法（借助栈）
function traveseTree(root, callback) {
    var stack = [];
    var p = root;
    if (root == null)
        return;
    while(stack.length || p) {
        // 第一步：遍历左子树，根节点入栈（为了后面根据根节点找到右子树）
        while(p) {
            stack.push(p);
            p = p.left;
        }
        // 第二步：出栈（p指向栈顶元素，取p的右子树重复以上过程，直到栈为空且p为空）
        callback(p = stack.pop());
        p = p.right;
    }
}

先序遍历（根左右）

// 递归写法
function traveseTree(root, callback) {
    if (root != null) {
        callback(root);
        traveseTree(root.left);
        traveseTree(root.right);
    }
}

// 非递归写法（借助栈）
function traveseTree(root, callback) {
    var p = root,
        stack = [];
    if (root == null) return;
    while(stack.length || p) {
        // 第一步：先遍历左子树，边遍历边打印，并将根节点存入栈中，以后借助跟节点进入右子树开启新一轮遍历
        while(p) {
            callback(p);
            stack.push(p);
            p = p.left;
        }
        p = stack.pop();
        p = p.right;
    }
}

后序遍历（左右根）

// 递归写法
function traveseTree(root, callback) {
    if (root != null) {
        traveseTree(root.left);
        traveseTree(root.right);
        callback(root);
    }
}

// 非递归写法（借助栈）
// 后序遍历的难点在于：需要判断上次访问的节点是位于左子树，还是右子树。若是位于左子树，则需跳过根节点，先进入右子树，再回头访问根节点；若是位于右子树，则直接访问根节点。
function traveseTree(root, callback) {
    var pCur = root, pLast = null, stack = [];
    if (root == null) return;
    // 先把pCur移到左子树最下边
    while(pCur) {
        stack.push(pCur);
        pCur = pCur.left;
    }
    while(stack.length) {
        pCur = stack.pop();
        //一个根节点被访问的前提是：无右子树或右子树已被访问过
        if (pCur.right == null || pCur.right == pLast) {
            callback(pCur);
            pLast = pCur;
        }
        /*这里的else语句可换成带条件的else if:
        else if (pCur->lchild == pLastVisit)//若左子树刚被访问过，则需先进入右子树(根节点需再次入栈)
        因为：上面的条件没通过就一定是下面的条件满足。仔细想想！
        */
        else {
            // 根节点再次入栈
            stack.push(pCur);
            // 进入右子树，且可肯定右子树一定不为空
            pCur = pCur.right;
            while(pCur) {
                stack.push(pCur);
                pCur = pCur.left;
            }
        }
    }
}

层次遍历（利用队列实现）

1. 根节点入队
2. 出队
3. 如果有左孩子，左孩子入队；如果有右孩子，右孩子入队。
4. 重复步骤2、3，直到队列为空。

function traveseTree(root, callback) {
    var queue = [];
    if (root == null) return null;
    queue.push(root);
    while(queue.length) {
        var frontNode = queue.shift();
        callback(frontNode);
        if (frontNode.left) queue.push(frontNode.left);
        if (frontNode.right) queue.push(frontNode.right);
    }
}

树的查找

• 最小值：左子树最下边
• 最大值：右子树最下边
• 特定值：先序遍历

树的删除

// 删除值为value的节点
function removeNode(node, value) {
    if (node == null) return null;
    if (value < node.value) {
        node.left = removeNode(node.left, value);
        return node;
    } else if (value > node.value) {
        node.right = removeNode(node.right, value);
        return node;
    } else {
        //情况1：节点为叶节点（有零个子节点的节点）
        if(node.left == null && node.right == null) {
            node = null;
            return node;
        }
        //情况2：只有一个子节点的节点
        if (node.left == null) {
            node = node.right;
            return node;
        } else if(node.right == null) {
            node = node.left;
            return node;
        }
        //情况3：有两个子节点的节点
        // 先找到右边子树节点的最小值节点
        // 再用最小值节点的值更新当前节点的值
        // 最后删除右边子树最小值节点
        var findMinNode = function(node) {
            if (node) {
                while(node && node.left !== null) {
                    node = node.left;
                }
                return node;
            }
            return null;
        }
        var aux = findMinNode(node.right);
        node.value = aux.value;
        node.right = removeNode(node.right, aux.value);
        return node;
    }
}

其他扩展

• 红黑树
• AVL平衡二叉搜索树

图

图的表示

• 邻接矩阵：顶点用数组索引表示，a[i][j] = 1来表示边。缺点是浪费一些空间。
• 邻接表：每个顶点的相邻顶点列表组成。
• 关联矩阵：行表示顶点，列表示边，a[i][j] = 1表示边j的入射顶点为i。

function Graph() {
    this.vertices = [];
    this.vertexMap = new Map();
    this.adjList = new Map();
    this.addVertex = function(v) {
        return this.vertexMap.has(v.id) ? null : (v.status = 0, this.vertexMap.set(v.id, v), this.vertices.push(v),this.adjList.set(v.id, new Set()), v);
    };
    this.addEdge = function(sourceId, targetId) {
        if (this.vertexMap.has(sourceId) && this.vertexMap.has(targetId)) {
            this.adjList.get(sourceId).add(this.vertexMap.get(targetId));
            this.adjList.get(targetId).add(this.vertexMap.get(sourceId));
        }
        return this;
    };
    this.getVertex = function(id) {
        return this.vertexMap.get(id);
    };
    this.getVertexAdj = function(id) {
        return this.adjList.get(id) || [];
    };
    this.toString = function() {
        this.adjList.forEach((value, key) => {
            console.log(key + ':' + Array.from(value).map(e => e.id).join(',') + '\n');
        });
    };
}

图的遍历

• 广度优先（BFS）：用队列实现。
• 深度优先（DFS）：用栈实现。

用 status 表示节点状态：

• 0 - 初始状态
• 1 - 被探索状态
• 2 - 被访问过状态

// 广度优先（BFS）算法：用**队列**实现。
/*
1. 创建一个队列 Q
2. 将 v 标记为 1，并入队
3. 如果 Q 非空，重复以下步骤
  3.1 将 u 出队
  3.2 寻找 u 的相邻节点，并将未被访问的节点入栈，并标记为 1
  3.3 访问节点，标记为 2
*/
function BFS(root, callback) {
    var queue = [];
    if (root == null) return null;
    root.status = 1 && queue.push(root);
    while(queue.length) {
        var curVertex = queue.shift();
        // 将相邻节点入队
        var adjVertexs = graph.getVertexAdj(curVertex.id);
        adjVertexs.forEach(e => {
            // 忽略已经入队或已经被访问过的节点
            if (e.status === 0) {
                e.status = 1 && queue.push(e);
            }
        });
        // 节点被访问
        callback(curVertex);
        curVertex.status = 2;
    }
}

// 深度优先（DFS）算法：用**栈**实现。
function DFS(graph, callback) {
    var stack = [];
    var vertexs = graph.vertices;
    // 遍历每个节点，若节点未被访问，则入栈
    // 若栈非空，出栈
    // 继续遍历其相邻未被访问的子节点
    for (var i = 0, length = vertexs.length; i < length; i++) {
        if (vertexs[i].status === 0) {
            vertexs[i].status = 1;
            stack.push(vertexs[i]);
            while(stack.length) {
                var v = stack.pop();
                v.status = 2;
                callback(v);
                var adjVertexs = graph.getVertexAdj(v.id);
                adjVertexs.forEach(e => {
                    if (e.status === 0) {
                        e.status = 1;
                        stack.push(e);
                    }
                });
            }
        }
    }
}

// 递归写法
function DFS(v, callback) {
    if (v == null) return;
    callback(v);
    v.status = 2;
    var adjVertexs = graph.getVertexAdj(v.id);
    adjVertexs.forEach(e => {
        if (e.status === 0) DFS(e, callback);
    });
}

排序和搜索算法

冒泡排序

两两比较，一轮比较后最大的数沉到底部。

两层循环：

• 外层循环表示比较的轮次
• 内层循环表示每一轮冒泡

function bubbleSort(arr) {
    for (var i = 0, len = arr.length; i < len; i++) {
        // 改进： j < len - 1 - i，已经排好序的可以不用再比较
        for(var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {
                swap(arr, j, j+1);
            }
        }
    }
}

选择排序

找到最小值，放到第一位；找到第二小的值，放到第二位，依次类推......。

function selectionSort(arr) {
    var minIndex;
    for (var i = 0; i < arr.length-1; i++) {
        minIndex = i;
        for (var j = i+1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        swap(arr, minIndex, i);
    }
}

插入排序

往已经排好序的数组里面插入待排序的元素。

假设数组第一项排好序，从第二项开始，与前面的比较，如果比前面小，继续向前，直到比前面的大。

function insertionSort(arr) {
    if (arr.length < 2) return arr;
    for (var i = 1, len = arr.length; i < len; i++) {
        var j = i - 1;
        var temp = arr[i]; // 相当于将i提取出，留个空位
        while(j >=0 && arr[j] > temp) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = temp;
    }
}

归并排序

归并排序是一种分治算法。其思想是将原始数组切分成较小的数组，直到每个小数组只有一
个位置，接着将小数组归并成较大的数组，直到最后只有一个排序完毕的大数组。

// https://www.cnblogs.com/chengxiao/p/6194356.html
function mergeSort(arr) {
    var len = arr.length;
    if (len === 1) return arr;
    var mid = Math.floor(len/2);
    var left = arr.slice(0, mid);
    var right = arr.slice(mid, len);
    return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right) {
    var i = 0,
        j = 0,
        l = left.length,
        r = right.length,
        temp = [];
    while(i < l && j < r) {
        if (left[i] < right[j]) {
            temp.push(left[i]);
            i++;
        } else {
            temp.push(right[j]);
            j++;
        }
    }
    if (i < l) {
        temp.push(...left.slice(i));
    }
    if (j < r) {
        temp.push(...right.slice(j));
    }
    return temp;
}

快速排序

分治算法。一次排序分两半，一半小，一半大，直到左指针大于右指针。

(1) 首先，从数组中选择中间一项作为主元。
(2) 创建两个指针，左边一个指向数组第一个项，右边一个指向数组最后一个项。移动左指
针直到我们找到一个比主元大的元素，接着，移动右指针直到找到一个比主元小的元素，然后交
换它们，重复这个过程，直到左指针超过了右指针。这个过程将使得比主元小的值都排在主元之前，而比主元大的值都排在主元之后。这一步叫作划分操作。
(3) 接着，算法对划分后的小数组（较主元小的值组成的子数组，以及较主元大的值组成的子数组）重复之前的两个步骤，直至数组已完全排序。

function quickSort(arr, left, right) {
    var index;
    if (arr.length > 1) {
        index = partition(arr, left, right);
        if (left < index - 1) {
            quickSort(arr, left, index-1);
        }
        if (right > index) {
            quickSort(arr, index, right);
        }
    }
}

function partition(arr, left, right) {
    var pivot = arr[Math.floor((left+right)/2)],
        i = left,
        j = right;
    while(i <= j) {
        while(arr[i] < pivot) {
            i++;
        }
        while(arr[j] > pivot) {
            j--;
        }
        if (i <= j) {
            swap(arr, i, j);
            i++;
            j--;
        }
    }
    return i;
}

// 《算法图解》思路
// 基线条件：空数组或长度为1的数组不需要排序
// 递归条件：每次选择一个基准值，得到三个部分（小于基准值 + 基准值 + 大于基准值）
// 对基准值两边的数组继续快排，并将最后的数组合并
function quickSort(arr) {
    if (arr.length < 2) return arr; // 基线条件
    var baseIndex = Math.floor(arr.length / 2); // 基准值
    var leftArr = [];
    var rightArr = [];
    for (var i = 0, len = arr.length; i < len; i++) {
        if (i !== baseIndex) {
            if (arr[i] < arr[baseIndex]) {
                leftArr.push(arr[i]); // 小于基准值部分
            } else {
                rightArr.push(arr[i]); // 大于基准值部分
            }
        }
    }
    // 最后合并
    return quickSort(leftArr).concat([arr[baseIndex]]).concat(quickSort(rightArr));
}

顺序搜索

一一对比。

二分搜索（二分查找）

对于已排好序的数组。

function binarySearch(arr, value) {
    var left = 0,
        right = arr.length - 1;
    var mid;
    while(left <= right) {
        mid = Math.floor((left+right)/2);
        if (value < arr[mid]) {
            right = mid - 1;
        } else if(value > arr[mid]){
            left = mid + 1;
        } else {
            return mid;
        }
    }
    return -1;
}

算法补充知识

递归

尾调用是指某个函数的最后一步是调用另一个函数。

尾调用优化

尾调用优化——记一道面试题的思考

朋友你听说过尾递归吗

尾递归的后续探究

// 递归
function fibonacci(num) {
    if (num === 1 || num === 2) return 1;
    return fibonacci(num-1) + fibonacci(num-2);
}

// 非递归
function fibonacci(num) {
    var n1 = 1, n2 = 1, n=1;
    for (var i = 3; i <= num; i++) {
        n = n1 + n2;
        n1 = n2;
        n2 = n;
    }
    return n;
}

动态规划（Dynamic Programming， DP）

是一种将复杂问题分解成更小的子问题来解决的优化技术。

要注意动态规划和分而治之（归并排序和快速排序算法中用到的那种）是不同的方法。
分而治之方法是把问题分解成相互独立的子问题，然后组合它们的答案，而动态规划则是将问题分解成相互依赖的子问题。

解决的问题：

• 背包问题：给出一组项目，各自有值和容量，目标是找出总值最大的项目的集合。这个
  问题的限制是，总容量必须小于等于“背包”的容量。

• 最长公共子序列：找出一组序列的最长公共子序列（可由另一序列删除元素但不改变余
  下元素的顺序而得到）。

• 矩阵链相乘：给出一系列矩阵，目标是找到这些矩阵相乘的最高效办法（计算次数尽可
  能少）。相乘操作不会进行，解决方案是找到这些矩阵各自相乘的顺序。

• 硬币找零：给出面额为d1…dn的一定数量的硬币和要找零的钱数，找出有多少种找零的
  方法。

• 图的全源最短路径：对所有顶点对(u, v)，找出从顶点u到顶点v的最短路

贪心算法

大 O 表示法

时间复杂度速查表

1. 前言

本文面试的内容包含：HTML + CSS + JS + ES6 + Webpack + Vue + React + Node + HTTPS + 数据结构与算法 + Git 。

复习前端面试的知识，是为了巩固前端的基础知识，最重要的还是平时的积累！

注意：文章的题与题之间用下划线分隔开，答案仅供参考。

2. HTML

为什么利用多个域名来存储网站资源会更有效 ？

利用多个域名来存储网站资源

• 确保用户在不同地区能用最快的速度打开网站，其中某个域名崩溃用户也能通过其他域名访问网站。
• CDN 缓存更方便。简单来说，CDN 主要用来使用户就近获取资源。
• 突破浏览器并发限制。同一时间针对同一域名下的请求有一定数量限制，超过限制数目的请求会被阻塞。大多数浏览器的并发数量都控制在6以内。有些资源的请求时间很长，因而会阻塞其他资源的请求。因此，对于一些静态资源，如果放到不同的域名下面就能实现与其他资源的并发请求。
• Cookieless, 节省带宽，尤其是上行带宽 一般比下行要慢。
• 对于 UGC 的内容和主站隔离，防止不必要的安全问题。
• 数据做了划分，甚至切到了不同的物理集群，通过子域名来分流比较省事. 这个可能被用的不多。

window 常用属性与方法有哪些 ？

window 对象的常用属性

• window.self 返回当前窗口的引用
• window.parent   返回当前窗体的父窗体对象
• window.top 返回当前窗体最顶层的父窗体的引用
• window.outerwidth       返回当前窗口的外部宽
• window.outerheight  返回当前窗口的外部高
• window.innerwidth       返回当前窗口的可显示区域宽
• window.innerheight  返回当前窗口的可显示区域高
   
  提示：通过直接在 Chrome 控制台中输入 console.log(window) 可以查看到其所有的被当前浏览器支持的属性及值。

window 对象的常用方法

• window.prompt()   弹出一个输入提示框，若用户点击了“取消”则返回 null
• window.alert()    弹出一个警告框
• window.confirm()  弹出一个确认框
• window.close()  关闭当前浏览器窗口。 有些浏览器对此方法有限制。
• window.open(uri, [name], [features])  打开一个浏览器窗口，显示指定的网页。name 属性值可以是“_blank”、“_self”、“_parent”、“_top”、任意指定的一个窗口名。
• window.blur( )    指定当前窗口失去焦点
• window.focus( ) 指定当前窗口获得焦点
• window.showModalDialog(uri, [dataFromParent])  打开一个“模态窗口”（打开的子窗口只要不关闭，其父窗口即无法获得焦点；且父子窗口间可以传递数据）

document 常用属性与方法有哪些 ？

document 常见的属性

• body 提供对 元素的直接访问。对于定义了框架集的文档，该属性引用最外层的 。
• cookie 设置或返回与当前文档有关的所有 cookie。
• domain 返回当前文档的域名。
• lastModified 返回文档被最后修改的日期和时间。
• referrer 返回载入当前文档的文档的 URL。
• title 返回当前文档的标题。
• URL 返回当前文档的 URL。

document常见的方法

• write()：动态向页面写入内容
• createElement(Tag)：创建一个 HTML 标签对象
• getElementById(ID)：获得指定 id 的对象
• getElementsByName(Name)：获得之前 Name 的对象
• body.appendChild(oTag)：向 HTML 中插入元素对象

简述一下 src 与 href 的区别

• href 是指向网络资源所在位置，建立和当前元素（锚点）或当前文档（链接）之间的链接，用于超链接。
• src 是指向外部资源的位置，指向的内容将会嵌入到文档中当前标签所在位置；
• 在请求 src 资源时会将其指向的资源下载并应用到文档内，例如 js 脚本，img 图片和 frame 等元素。
  当浏览器解析到该元素时，会暂停其他资源的下载和处理，直到将该资源加载、编译、执行完毕，图片和框架等元素也如此，类似于将所指向资源嵌入当前标签内。这也是为什么将 js 脚本放在底部而不是头部。

写一个 div + css 布局，左边图片，右边文字，文字环绕图片，外面容器固定宽度，文字不固定。

直接就一个 img，它 float：left，加文字加 p 标签就好了。

html 中 title 属性和 alt 属性的区别 ？

1. alt

<img src="#" alt="alt 信息" />

当图片不输出信息的时候，会显示 alt 信息， 鼠标放上去没有信息。
当图片正常读取，不会出现 alt 信息。

1. title

<img src="#" alt="alt 信息" title="title 信息" />

当图片不输出信息的时候，会显示 alt 信息，鼠标放上去会出现 title 信息。
当图片正常输出的时候，不会出现 alt 信息，鼠标放上去会出现 title 信息。

讲述你对 reflow 和 repaint 的理解。

repaint 就是重绘，reflow 就是回流。

严重性： 在性能优先的前提下，性能消耗 reflow 大于 repaint。

体现：repaint 是某个 DOM 元素进行重绘；reflow 是整个页面进行重排，也就是页面所有 DOM 元素渲染。

如何触发： style 变动造成 repaint 和 reflow。

1. 不涉及任何 DOM 元素的排版问题的变动为 repaint，例如元素的 color/text-align/text-decoration 等等属性的变动。
2. 除上面所提到的 DOM 元素 style 的修改基本为 reflow。例如元素的任何涉及 长、宽、行高、边框、display 等 style 的修改。

常见触发场景

触发 repaint：

• color 的修改，如 color=#ddd；
• text-align 的修改，如 text-align=center；
• a:hover 也会造成重绘。
• :hover 引起的颜色等不导致页面回流的 style 变动。

触发 reflow：

• width/height/border/margin/padding 的修改，如 width=778px；
• 动画，:hover 等伪类引起的元素表现改动，display=none 等造成页面回流；
• appendChild 等 DOM 元素操作；
• font 类 style 的修改；
• background 的修改，注意着字面上可能以为是重绘，但是浏览器确实回流了，经过浏览器厂家的优化，部分 background 的修改只触发 repaint，当然 IE 不用考虑；
• scroll 页面，这个不可避免；
• resize 页面，桌面版本的进行浏览器大小的缩放，移动端的话，还没玩过能拖动程序，resize 程序窗口大小的多窗口操作系统。
• 读取元素的属性（这个无法理解，但是技术达人是这么说的，那就把它当做定理吧）：读取元素的某些属性（offsetLeft、offsetTop、offsetHeight、offsetWidth、scrollTop/Left/Width/Height、clientTop/Left/Width/Height、getComputedStyle()、currentStyle(in IE))；

如何避免： 

• 尽可能在 DOM 末梢通过改变 class 来修改元素的 style 属性：尽可能的减少受影响的 DOM 元素。
• 避免设置多项内联样式：使用常用的 class 的方式进行设置样式，以避免设置样式时访问 DOM 的低效率。
• 设置动画元素 position 属性为 fixed 或者 absolute：由于当前元素从 DOM 流中独立出来，因此受影响的只有当前元素，元素 repaint。
• 牺牲平滑度满足性能：动画精度太强，会造成更多次的 repaint/reflow，牺牲精度，能满足性能的损耗，获取性能和平滑度的平衡。
• 避免使用 table 进行布局：table 的每个元素的大小以及内容的改动，都会导致整个 table 进行重新计算，造成大幅度的 repaint 或者 reflow。改用 div 则可以进行针对性的 repaint 和避免不必要的 reflow。
• 避免在 CSS 中使用运算式：学习 CSS 的时候就知道，这个应该避免，不应该加深到这一层再去了解，因为这个的后果确实非常严重，一旦存在动画性的 repaint/reflow，那么每一帧动画都会进行计算，性能消耗不容小觑。

参考文章：你真的了解回流和重绘吗

• 我终于理解了伪类和伪元素

Doctype 作用 ？标准模式与兼容模式各有什么区别 ?

• 声明位于位于 HTML 文档中的第一行，处于 标签之前。告知浏览器的解析器用什么文档标准解析这个文档。DOCTYPE 不存在或格式不正确会导致文档以兼容模式呈现。
• 标准模式的排版和 JS 运作模式都是以该浏览器支持的最高标准运行。在兼容模式中，页面以宽松的向后兼容的方式显示，模拟老式浏览器的行为以防止站点无法工作。

HTML5 为什么只需要写 < !DOCTYPE HTML> ？

HTML5 不基于 SGML(标准通用标记语言（以下简称“通用标言”)，因此不需要对 DTD 进行引用，但是需要 doctype 来规范浏览器的行为（让浏览器按照它们应该的方式来运行）；
而 HTML4.01 基于 SGML，所以需要对 DTD 进行引用，才能告知浏览器文档所使用的文档类型。

行内元素有哪些 ？块级元素有哪些 ？ 空(void)元素有那些 ？

CSS 规范规定，每个元素都有 display 属性，确定该元素的类型，每个元素都有默认的 display 值。
如 div 的 display 默认值为 “block”，则为“块级”元素；
span 默认 display 属性值为 “inline”，是“行内”元素。

• 行内元素有：a b span img input select strong（强调的语气）
• 块级元素有：div ul ol li dl dt dd h1 h2 h3 h4 p
• 常见的空元素： img input link meta br hr ，鲜为人知的是：area base col command embed keygen param source track wbr

HTML5 有哪些新特性、移除了那些元素 ？如何处理 HTML5 新标签的浏览器兼容问题 ？如何区分 HTML 和 HTML5 ？

HTML5 现在已经不是 SGML（标准通用标记语言）的子集，主要是关于图像，位置，存储，多任务等功能的增加。

新特性

• 绘画 canvas;
• 用于媒介回放的 video 和 audio 元素;
• 本地离线存储 localStorage 长期存储数据，浏览器关闭后数据不丢失;
• sessionStorage 的数据在浏览器关闭后自动删除;
• 语意化更好的内容元素，比如 article、footer、header、nav、section;
• 表单控件：calendar、date、time、email、url、search;
• 新的技术：webworker, websocket, Geolocation;

移除的元素

• 纯表现的元素：basefont，big，center，font, s，strike，tt，u;
• 对可用性产生负面影响的元素：frame，frameset，noframes；

支持 HTML5 新标签

• IE8/IE7/IE6 支持通过 document.createElement 方法产生的标签，可以利用这一特性让这些浏览器支持 HTML5 新标签，浏览器支持新标签后，还需要添加标签默认的样式。
• 当然也可以直接使用成熟的框架、比如 html5shim;

<!--[if lt IE 9]>
<script> src="http://html5shim.googlecode.com/svn/trunk/html5.js"</script>
<![endif]-->

简述一下你对 HTML 语义化的理解 ？

• 1、用正确的标签做正确的事情。
• 2、html 语义化让页面的内容结构化，结构更清晰，
• 3、便于对浏览器、搜索引擎解析;
• 4、即使在没有样式 CSS 情况下也以一种文档格式显示，并且是容易阅读的;
• 5、搜索引擎的爬虫也依赖于 HTML 标记来确定上下文和各个关键字的权重，利于 SEO;
• 6、使阅读源代码的人对网站更容易将网站分块，便于阅读维护理解。

HTML5 的离线储存怎么使用，工作原理能不能解释一下 ？

在用户没有与因特网连接时，可以正常访问站点或应用，在用户与因特网连接时，更新用户机器上的缓存文件。

原理

HTML5 的离线存储是基于一个新建的 .appcache 文件的缓存机制(不是存储技术)，通过这个文件上的解析清单离线存储资源，这些资源就会像 cookie 一样被存储了下来。之后当网络在处于离线状态下时，浏览器会通过被离线存储的数据进行页面展示。

如何使用

• 1、页面头部像下面一样加入一个 manifest 的属性；
• 2、在 cache.manifest 文件的编写离线存储的资源；

CACHE MANIFEST
#v0.11
CACHE:
js/app.js
css/style.css
NETWORK:
resourse/logo.png
FALLBACK:
//offline.html

• 3、在离线状态时，操作 window.applicationCache 进行需求实现。

浏览器是怎么对 HTML5 的离线储存资源进行管理和加载的呢 ？

在线的情况下，浏览器发现 html 头部有 manifest 属性，它会请求 manifest 文件，如果是第一次访问 app，那么浏览器就会根据 manifest 文件的内容下载相应的资源并且进行离线存储。

如果已经访问过 app 并且资源已经离线存储了，那么浏览器就会使用离线的资源加载页面，然后浏览器会对比新的 manifest 文件与旧的 manifest 文件，如果文件没有发生改变，就不做任何操作，如果文件改变了，那么就会重新下载文件中的资源并进行离线存储。

离线的情况下，浏览器就直接使用离线存储的资源。

请描述一下 cookies，sessionStorage 和 localStorage 的区别 ？

• cookie 是网站为了标示用户身份而储存在用户本地终端（Client Side）上的数据（通常经过加密）。
• cookie 数据始终在同源的 http 请求中携带（即使不需要），也会在浏览器和服务器间来回传递。
• sessionStorage 和 localStorage 不会自动把数据发给服务器，仅在本地保存。

存储大小

• cookie 数据大小不能超过 4k。
• sessionStorage 和 localStorage 虽然也有存储大小的限制，但比 cookie 大得多，可以达到 5M 或更大。

有期时间

• localStorage 存储持久数据，浏览器关闭后数据不丢失除非主动删除数据；
• sessionStorage 数据在当前浏览器窗口关闭后自动删除。
• cookie  设置的 cookie 过期时间之前一直有效，即使窗口或浏览器关闭。

iframe 内嵌框架有那些缺点 ？

内联框架 iframe一般用来包含别的页面，例如 我们可以在我们自己的网站页面加载别人网站的内容，为了更好的效果，可能需要使 iframe 透明效果；

• iframe 会阻塞主页面的 onload 事件；
• 搜索引擎的检索程序无法解读这种页面，不利于 SEO 搜索引擎优化（Search Engine Optimization）
• iframe 和主页面共享连接池，而浏览器对相同域的连接有限制，所以会影响页面的并行加载。

如果需要使用 iframe，最好是通过 javascript 动态给 iframe 添加 src 属性值，这样可以绕开以上两个问题。

Label 的作用是什么？是怎么用的 ？

label 标签来定义表单控制间的关系，当用户选择该标签时，浏览器会自动将焦点转到和标签相关的表单控件上。

<label for="Name">Number:</label>
<input type=“text“ name="Name"  id="Name"/>

<label>Date:<input type="text" name="B"/></label>

HTML5 的 form 如何关闭自动完成功能 ？

给不想要提示的 form 或某个 input 设置为 autocomplete=off。

如何实现浏览器内多个标签页之间的通信 ? (阿里)

• WebSocket、SharedWorker；
• 也可以调用 localstorge、cookies 等本地存储方式；
• localstorge 在另一个浏览上下文里被添加、修改或删除时，它都会触发一个事件，我们通过监听事件，控制它的值来进行页面信息通信；
  注意 quirks：Safari 在无痕模式下设置 localstorge 值时会抛出 QuotaExceededError 的异常；

webSocket 如何兼容低浏览器 ？(阿里)

• Adobe Flash Socket 、
• ActiveX HTMLFile (IE) 、
• 基于 multipart 编码发送 XHR 、
• 基于长轮询的 XHR。

页面可见性（Page Visibility API） 可以有哪些用途 ？

• 通过 visibilityState 的值检测页面当前是否可见，以及打开网页的时间等;
• 在页面被切换到其他后台进程的时候，自动暂停音乐或视频的播放；

网页验证码是干嘛的，是为了解决什么安全问题。

• 区分用户是计算机还是人的公共全自动程序；
• 可以防止恶意破解密码、刷票、论坛灌水；
• 有效防止黑客对某一个特定注册用户用特定程序暴力破解方式进行不断的登陆尝试。

title 与 h1 的区别、b 与 strong 的区别、i 与 em 的区别 ？

• title 属性没有明确意义只表示是个标题，H1 则表示层次明确的标题，对页面信息的抓取也有很大的影响；

• strong 是标明重点内容，有语气加强的含义，使用阅读设备阅读网络时：strong 会重读，而 b 是展示强调内容。

• i 内容展示为斜体，em 表示强调的文本；

• Physical Style Elements -- 自然样式标签：b, i, u, s, pre

• Semantic Style Elements -- 语义样式标签：strong, em, ins, del, code

• 应该准确使用语义样式标签, 但不能滥用, 如果不能确定时，首选使用自然样式标签。

谈谈以前端的角度出发，做好 SEO ，需要考虑什么 ？

• 了解搜索引擎如何抓取网页和如何索引网页。
  你需要知道一些搜索引擎的基本工作原理，各个搜索引擎之间的区别，搜索机器人（SE robot 或叫 web cra何进行工作，搜索引擎如何对搜索结果进行排序等等。
• Meta 标签优化
  主要包括主题（Title)，网站描述(Description)，和关键词（Keywords）。还有一些其它的隐藏文字比如 Au 者），Category（目录），Language（编码语种）等。
• 如何选取关键词并在网页中放置关键词。
  搜索就得用关键词。关键词分析和选择是 SEO 最重要的工作之一。首先要给网站确定主关键词（一般在 5 个上后针对这些关键词进行优化，包括关键词密度（Density），相关度（Relavancy），突出性（Prominency）等等。
• 了解主要的搜索引擎。
  虽然搜索引擎有很多，但是对网站流量起决定作用的就那么几个。比如英文的主要有 Google，Yahoo，Bing 等有百度，搜狗，有道等。
  不同的搜索引擎对页面的抓取和索引、排序的规则都不一样。
  还要了解各搜索门户和搜索的关系，比如 AOL 网页搜索用的是 Google 的搜索技术，MSN 用的是 Bing 的技术。
• 主要的互联网目录。
  Open Directory 自身不是搜索引擎，而是一个大型的网站目录，他和搜索引擎的主要区别是网站内容的收集方目录是人工编辑的，主要收录网站主页；搜索引擎是自动收集的，除了主页外还抓取大量的内容页面。
• 按点击付费的搜索引擎。
  搜索引擎也需要生存，随着互联网商务的越来越成熟，收费的搜索引擎也开始大行其道。最典型的有 Overture 当然也包括 Google 的广告项目 Google Adwords。越来越多的人通过搜索引擎的点击广告来定位商业网站，这里面化和排名的学问，你得学会用最少的广告投入获得最多的点击。
• 搜索引擎登录。
  网站做完了以后，别躺在那里等着客人从天而降。要让别人找到你，最简单的办法就是将网站提交（submit）擎。如果你的是商业网站，主要的搜索引擎和目录都会要求你付费来获得收录（比如 Yahoo 要 299 美元），但是好消少到目前为止）最大的搜索引擎 Google 目前还是免费，而且它主宰着 60％ 以上的搜索市场。
• 链接交换和链接广泛度（Link Popularity）。
  网页内容都是以超文本（Hypertext）的方式来互相链接的，网站之间也是如此。除了搜索引擎以外，人们也不同网站之间的链接来 Surfing（“冲浪”）。其它网站到你的网站的链接越多，你也就会获得更多的访问量。更重你的网站的外部链接数越多，会被搜索引擎认为它的重要性越大，从而给你更高的排名。
• 标签的合理使用。

前端页面有哪三层构成，分别是什么？作用是什么？

网页分成三个层次，即：结构层、表示层、行为层。

• 网页的结构层（structurallayer）由 HTML 或 XHTML 之类的标记语言负责创建。
  标签，也就是那些出现在尖括号里的单词，对网页内容的语义含义做出这些标签不包含任何关于如何显示有关内容的信息。例如，P 标签表达了这样一种语义：“这是一个文本段。”
• 网页的表示层（presentationlayer）由 CSS 负责创建。CSS 对“如何显示有关内容”的问题做出了回答。
• 网页的行为层（behaviorlayer）负责回答 “内容应该如何对事件做出反应” 这一问题。
  这是 Javascript 语言和 DOM 主宰的领域。

有这么一段 HTML，请挑毛病

哥写的不是HTML，是寂寞。< br>< br> 我说：< br>不要迷恋哥，哥只是一个传说

答案：缺少 p 标记的结束标记。

3. CSS

盒子模型的理解 ?

• 标准模式和混杂模式（IE）。
• 在标准模式下浏览器按照规范呈现页面；
• 在混杂模式下，页面以一种比较宽松的向后兼容的方式显示。
• 混杂模式通常模拟老式浏览器的行为以防止老站点无法工作。

CSS 盒子模型具有内容 (content)、填充 (padding)、边框 (border)、边界 (margin)这些属性。

我们所说的 width，height 指的是内容 (content) 的宽高。

一个盒子模型的中：

• 宽度 = width+ pdding(宽) + border(宽)。
• 高度 = height + padding(高) + border(高)。

如何在页面上实现一个圆形的可点击区域 ？

• 1、map+area 或者 svg
• 2、border-radius
• 3、纯 js 实现，需要求一个点在不在圆上简单算法、获取鼠标坐标等等

实现不使用 border 画出 1px 高的线，在不同浏览器的标准模式与怪异模式下都能保持一致的效果。

<div style="height:1px;overflow:hidden;background:red"></div>

CSS 中哪些属性可以同父元素继承 ?

继承：(X)HTML 元素可以从其父元素那里继承部分 CSS 属性，即使当前元素并没有定义该属性，比如： color，font-size。

box-sizing 常用的属性有哪些 ？分别有什么作用 ？

常用的属性：box-sizing: content-box border-box inherit;

作用

content-box(默认)：宽度和高度分别应用到元素的内容框。在宽度和高度之外绘制元素的内边距和边框(元素默认效果)。
border-box：元素指定的任何内边距和边框都将在已设定的宽度和高度内进行绘制。通过从已设定的宽度和高度分别减去边框和内边距才能得到内容的宽度和高度。

页面导入样式时，使用 link 和 @import 有什么区别 ？

• link 属于 XHTML 标签，除了加载 CSS 外，还能用于定义 RSS(是一种描述和同步网站内容的格式，是使用最广泛的 XML 应用), 定义 rel 连接属性等作用；
• 而 @import 是 CSS 提供的，只能用于加载 CSS;
• 页面被加载的时，link 会同时被加载，而 @import 引用的 CSS 会等到页面被加载完再加载;
• import 是 CSS2.1 提出的，只在 IE5 以上才能被识别，而 link 是 XHTML 标签，无兼容问题。
• 总之，link 要优于 @import。

常见兼容性问题？

• 浏览器默认的 margin 和 padding 不同。解决方案是加一个全局的 *{margin: 0; padding: 0;} 来统一。

• IE下 event 对象有 event.x，event.y 属性，而 Firefox 下没有。Firefox 下有 event.pageX，event.PageY 属性，而 IE 下没有。
  解决办法：var mx = event.x?event.x:event.pageX;

• Chrome 中文界面下默认会将小于 12px 的文本强制按照 12px 显示, 可通过加入 CSS 属性 -webkit-text-size-adjust: none; 解决.

• 超链接访问过后 hover 样式就不出现了，被点击访问过的超链接样式不在具有 hover 和 active 了，解决方法是改变 CSS 属性的排列顺序:
  L-V-H-A : a:link {} a:visited {} a:hover {} a:active {}

清除浮动，什么时候需要清除浮动，清除浮动都有哪些方法 ？

一个块级元素如果没有设置 height，那么其高度就是由里面的子元素撑开，如果子元素使用浮动，脱离了标准的文档流，那么父元素的高度会将其忽略，如果不清除浮动，父元素会出现高度不够，那样如果设置 border 或者 background 都得不到正确的解析。

正是因为浮动的这种特性，导致本属于普通流中的元素浮动之后，包含框内部由于不存在其他普通流元素了，也就表现出高度为 0（高度塌陷）。在实际布局中，往往这并不是我们所希望的，所以需要闭合浮动元素，使其包含框表现出正常的高度。

清除浮动的方式

• 父级 div 定义 height，原理：父级 div 手动定义 height，就解决了父级 div 无法自动获取到高度的问题。 
• 结尾处加空 div 标签 clear: both，原理：添加一个空 div，利用 css 提高的 clear: both 清除浮动，让父级 div 能自动获取到高度。
• 父级 div 定义 overflow: hidden，  原理：必须定义 width 或 zoom: 1，同时不能定义 height，使用 overflow: hidden 时，浏览器会自动检查浮动区域的高度。 
• 父级 div 也一起浮动 。
• 父级 div 定义 display: table 。
• 父级 div 定义 伪类 :after 和 zoom 。
• 结尾处加 br 标签 clear: both， 原理：父级 div 定义 zoom: 1 来解决 IE 浮动问题，结尾处加 br 标签 clear: both。

总结：比较好的是倒数第 2 种方式，简洁方便。

如何保持浮层水平垂直居中 ？

一、水平居中 

（1）行内元素解决方案

只需要把行内元素包裹在一个属性 display 为 block 的父层元素中，并且把父层元素添加如下属性即可。

.parent {
    text-align: center;
}

（2）块状元素解决方案
 

.item {
    /* 这里可以设置顶端外边距 */
    margin: 10px auto;
}

（3）多个块状元素解决方案将元素的 display 属性设置为 inline-block，并且把父元素的 text-align 属性设置为 center 即可:

.parent {
    text-align:center;
}

（4）多个块状元素解决方案

使用 flexbox 布局，只需要把待处理的块状元素的父元素添加属性 display: flex 及 justify-content: center 即可。

.parent {
    display: flex;
    justify-content: center;
}

二、垂直居中

（1）单行的行内元素解决方案

.parent {
    background: #222;
    height: 200px;
}

/* 以下代码中，将 a 元素的 height 和 line-height 设置的和父元素一样高度即可实现垂直居中 */
a {
    height: 200px;
    line-height:200px; 
    color: #FFF;
}

（2）多行的行内元素解决方案组合

使用 display: table-cell 和 vertical-align: middle 属性来定义需要居中的元素的父容器元素生成效果，如下：

.parent {
    background: #222;
    width: 300px;
    height: 300px;
    /* 以下属性垂直居中 */
    display: table-cell;
    vertical-align: middle;
}

（3）已知高度的块状元素解决方案

.item{
    position: absolute;
    top: 50%;
    margin-top: -50px;  /* margin-top值为自身高度的一半 */
    padding:0;
}

三、水平垂直居中

（1）已知高度和宽度的元素解决方案 1

这是一种不常见的居中方法，可自适应，比方案 2 更智能，如下：

.item{
    position: absolute;
    margin:auto;
    left:0;
    top:0;
    right:0;
    bottom:0;
}

（2）已知高度和宽度的元素解决方案 2

.item{
    position: absolute;
    top: 50%;
    left: 50%;
    margin-top: -75px;  /* 设置margin-left / margin-top 为自身高度的一半 */
    margin-left: -75px;
}

（3）未知高度和宽度元素解决方案

.item{
    position: absolute;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);  /* 使用 css3 的 transform 来实现 */
}

（4）使用 flex 布局实现

.parent{
    display: flex;
    justify-content: center;
    align-items: center;
    /* 注意这里需要设置高度来查看垂直居中效果 */
    background: #AAA;
    height: 300px;
}

position 、float 和 display 的取值和各自的意思和用法

position

• position 属性取值：static(默认)、relative、absolute、fixed、inherit、sticky。
• postision：static；始终处于文档流给予的位置。看起来好像没有用，但它可以快速取消定位，让 top，right，bottom，left 的值失效。在切换的时候可以尝试这个方法。
• 除了 static 值，在其他三个值的设置下，z-index 才会起作用。确切地说 z-index 只在定位元素上有效。
• position：relative 和 absolute 都可以用于定位，区别在于前者的 div 还属于正常的文档流，后者已经是脱离了正常文档流，不占据空间位置，不会将父类撑开。
  定位原点 relative 是相对于它在正常流中的默认位置偏移，它原本占据的空间任然保留；absolute 相对于第一个 position 属性值不为 static 的父类。所以设置了 position：absolute，其父类的该属性值要注意，而且 overflow：hidden 也不能乱设置，因为不属于正常文档流，不会占据父类的高度，也就不会有滚动条。
• fixed 旧版本 IE 不支持，却是很有用，定位原点相对于浏览器窗口，而且不能变。
  常用于 header，footer 或者一些固定的悬浮 div，随滚动条滚动又稳定又流畅，比 JS 好多了。fixed 可以有很多创造性的布局和作用，兼容性是问题。
• position：inherit。
  规定从父类继承 position 属性的值，所以这个属性也是有继承性的，但需要注意的是 IE8 以及往前的版本都不支持 inherit 属性。
• sticky ：设置了sticky 的元素，在屏幕范围（viewport）时该元素的位置并不受到定位影响（设置是 top、left 等属性无效），当该元素的位置将要移出偏移范围时，定位又会变成 fixed，根据设置的 left、top 等属性成固定位置的效果。

float

• float：left (或 right)，向左（或右）浮动，直到它的边缘碰到包含框或另一个浮动框为止。
  且脱离普通的文档流，会被正常文档流内的块框忽略。不占据空间，无法将父类元素撑开。
• 任何元素都可以浮动，浮动元素会生成一个块级框，不论它本身是何种元素。因此，没有必要为浮动元素设置 display：block。
• 如果浮动非替换元素，则要指定一个明确的 width，否则它们会尽可能的窄。
  什么叫替换元素 ？根据元素本身的特点定义的， (X)HTML中的 img、input、textarea、select、object 都是替换元素，这些元素都没有实际的内容。 (X)HTML 的大多数元素是不可替换元素，他们将内容直接告诉浏览器，将其显示出来。

display

• display 属性取值：none、inline、inline-block、block、table 相关属性值、inherit。
• display 属性规定元素应该生成的框的类型。文档内任何元素都是框，块框或行内框。
• display：none 和 visiability：hidden 都可以隐藏 div，区别有点像 absolute 和 relative，前者不占据文档的空间，后者还是占据文档的位置。
• display：inline 和 block，又叫行内元素和块级元素。
  表现出来的区别就是 block 独占一行，在浏览器中通常垂直布局，可以用 margin 来控制块级元素之间的间距（存在 margin 合并的问题，只有普通文档流中块框的垂直外边距才会发生外边距合并。行内框、浮动框或绝对定位之间的外边距不会合并。）；
  而 inline 以水平方式布局，垂直方向的 margin 和 padding 都是无效的，大小跟内容一样，且无法设置宽高。
  inline 就像塑料袋，内容怎么样，就长得怎么样；block 就像盒子，有固定的宽和高。
• inline-block 就介于两者之间。
• table 相关的属性值可以用来垂直居中，效果一般。
• flex

定位机制

上面三个属性都属于 CSS 定位属性。CSS 三种基本的定位机制：普通流、浮动、绝对定位。

css3 动画效果属性有哪些 ?

• animation-name：规定需要绑定到选择器的 keyframe 名称。。
• animation-duration：规定完成动画所花费的时间，以秒或毫秒计。
• animation-timing-function：规定动画的速度曲线。
• animation-delay：规定在动画开始之前的延迟。
• animation-iteration-count：规定动画应该播放的次数。
• animation-direction：规定是否应该轮流反向播放动画。

会不会用 ps 扣图，png、jpg、gif 这些图片格式解释一下，分别什么时候用。如何优化图像、图像格式的区别 ?

JPG 的特性

• 支持摄影图像或写实图像的高级压缩，并且可利用压缩比例控制图像文件大小。
• 有损压缩会使图像数据质量下降，并且在编辑和重新保存 JPG 格式图像时，这种下降损失会累积。
• JPG 不适用于所含颜色很少、具有大块颜色相近的区域或亮度差异十分明显的较简单的图片。

PNG 的特性

• 能在保证最不失真的情况下尽可能压缩图像文件的大小。
• PNG 用来存储灰度图像时，灰度图像的深度可多到 16 位，存储彩色图像时，彩色图像的深度可多到 48 位，并且还可存储多到 16 位的 α 通道数据。
• 对于需要高保真的较复杂的图像，PNG 虽然能无损压缩，但图片文件较大，不适合应用在 Web 页面上。
• 另外还有一个原则就是用于页面结构的基本视觉元素，如容器的背景、按钮、导航的背景等应该尽量用 PNG 格式进行存储，这样才能更好的保证设计品质。而其他一些内容元素，如广告 Banner、商品图片 等对质量要求不是特别苛刻的，则可以用 JPG 去进行存储从而降低文件大小。

GIF格式特点
 

• 透明性: Gif 是一种布尔透明类型，既它可以是全透明，也可以是全不透明，但是它并没有半透明（alpha 透明）。 
• 动画：Gif 这种格式支持动画。 
• 无损耗性：Gif 是一种无损耗的图像格式，这也意味着你可以对 gif 图片做任何操作也不会使得图像质量产生损耗。 
• 水平扫描：Gif 是使用了一种叫作 LZW 的算法进行压缩的，当压缩 gif 的过程中，像素是由上到下水平压缩的，这也意味着同等条件下，横向的 gif 图片比竖向的 gif 图片更加小。
  例如 50010 的图片比 10500 的图片更加小。
  间隔渐进显示：Gif 支持可选择性的间隔渐进显示。 

由以上特点看出只有 256 种颜色的 gif 图片不适合作为照片，它适合做对颜色要求不高的图形。

我们知道可以以外链的方式引入 CSS 文件，请谈谈外链引入 CSS 有哪些方式，这些方式的性能有区别吗 ？

CSS 的引入方式最常用的有三种

第一：外链式

这种方法可以说是现在占统治地位的引入方法。

如同 IE 与浏览器。这也是最能体现 CSS 特点的方法；

最能体现 DIV+CSS 中的内容离的思想，也最易改版维护，代码看起来也是最美观的一种。

第二：内部样式表

这种方法的使用情况要少的多，最长见得就是访问量大的门户网站。或者访问量较大的企业网站的首页。

与第一种方法比起来，优弊端也明显。

优点：速度快，所有的 CSS 控制都是针对本页面标签的，没有多余的 CSS 命令；再者不用外链 CSS 文件。直接在文档中读取样式。

缺点：就是改版麻烦些，单个页面显得臃肿，CSS 不能被其他 HTML 引用造成代码量相对较多，维护也麻烦些采用这种方法的公司大多有钱，对他们来说用户量是关键，他们不缺人进行复杂的维护工作。

第三：行内样式

认为 HTML 里不能出现 CSS 命令。其实有时候没有什么大不了。比如通用性差，效果特殊，使用 CSS 命令较少，并且不常改动的地方，使用这种方法反而是很好的选择。

第四、@import 引入方式

<style type="text/css">
@import url(my.css);
</style>

CSS Sprite 是什么，谈谈这个技术的优缺点。

加速的关键，不是降低重量，而是减少个数。传统切图讲究精细，图片规格越小越好，重量越小越好，其实规格大小无计算机统一都按 byte 计算。客户端每显示一张图片都会向服务器发送请求。所以，图片越多请求次数越多，造成延迟的可越大。

• 利用 CSS Sprites 能很好地减少了网页的 http 请求，从而大大的提高了页面的性能，这也是CSS Sprites 的优点，也是其被广泛传播和应用的主要原因；
• CSS Sprites 能减少图片的字节，曾经比较过多次 3 张图片合并成 1 张图片的字节总是小于这 3 张图片的和。
• 解决了网页设计师在图片命名上的困扰，只需对一张集合的图片上命名就可以了，不需要对每一个小元素名，从而提高了网页的制作效率。
• 更换风格方便，只需要在一张或少张图片上修改图片的颜色或样式，整个网页的风格就可以改变。维护起方便。

诚然 CSS Sprites 是如此的强大，但是也存在一些不可忽视的缺点，如下：

• 在图片合并的时候，你要把多张图片有序的合理的合并成一张图片，还要留好足够的空间，防止板块内不不必要的背景；这些还好，最痛苦的是在宽屏，高分辨率的屏幕下的自适应页面，你的图片如果不够宽，很容背景断裂；
• CSS Sprites 在开发的时候比较麻烦，你要通过 photoshop 或其他工具测量计算每一个背景单元的精确位是针线活，没什么难度，但是很繁琐；
• CSS Sprites 在维护的时候比较麻烦，如果页面背景有少许改动，一般就要改这张合并的图片，无需改的好不要动，这样避免改动更多的 css，如果在原来的地方放不下，又只能（最好）往下加图片，这样图片的字加了，还要改动 css。

CSS Sprites 非常值得学习和应用，特别是页面有一堆 ico（图标）。总之很多时候大家要权衡一下再决定是不是应用 CSS Sprites。

以 CSS3 标准定义一个 webkit 内核浏览器识别的圆角（尺寸随意）

-moz-border-radius: 10px; 
-webkit-border-radius: 10px;
 border-radius: 10px;。

优先级算法如何计算？内联和 important 哪个优先级高 ？

• 优先级就近原则，样式定义最近者为准
• 载入样式以最后载入的定位为准
• 优先级为 !important > [ id > class > tag ]
• !mportant 比内联优先级高

css 的基本语句构成是 ？

回答：选择器、属性和属性值。

如果让你来制作一个访问量很高的大型网站，你会如何来管理所有 CSS 文件、JS 与图片？

回答：涉及到人手、分工、同步；

• 先期团队必须确定好全局样式（globe.css），编码模式 (utf-8) 等
• 编写习惯必须一致（例如都是采用继承式的写法，单样式都写成一行）；
• 标注样式编写人，各模块都及时标注（标注关键样式调用的地方）；
• 页面进行标注（例如页面模块开始和结束）；
• CSS 跟 HTML 分文件夹并行存放，命名都得统一（例如 style.css）
• JS 分文件夹存放，命名以该 JS 功能为准
• 图片采用整合的 png8 格式文件使用，尽量整合在一起使用，方便将来的管理。

CSS 选择符有哪些 ？哪些属性可以继承 ？优先级算法如何计算 ？新增伪类有那些 ？

CSS 选择符

1. id选择器（ # myid）
2. 类选择器（.myclassname）
3. 标签选择器（div, h1, p）
4. 相邻选择器（h1 + p）
5. 子选择器（ul > li）
6. 后代选择器（li a）
7. 通配符选择器（ * ）
8. 属性选择器（a[rel = "external"]）
9. 伪类选择器（a: hover, li: nth - child）

可继承的样式

font-size，font-family，color，ul，li，dl，dd，dt；

不可继承的样式

border padding margin width height
事实上，宽度也不是继承的，而是如果你不指定宽度，那么它就是 100%。由于你子 DIV 并没有指定宽度，那它就是 100%，也就是与父 DIV 同宽，但这与继承无关，高度自然也没有继承一说。

优先级算法

优先级就近原则，同权重情况下样式定义最近者为准;
载入样式以最后载入的定位为准;
优先级为: !important > id > class > tag , important 比 内联优先级高

CSS3 新增伪类举例

• :root 选择文档的根元素，等同于 html 元素
• :empty 选择没有子元素的元素
• :target 选取当前活动的目标元素
• :not(selector) 选择除 selector 元素以外的元素
• :enabled 选择可用的表单元素
• :disabled 选择禁用的表单元素
• :checked 选择被选中的表单元素
• :after 选择器在被选元素的内容后面插入内容
• :before 选择器在被选元素的内容前面插入内容
• :nth-child(n) 匹配父元素下指定子元素，在所有子元素中排序第 n
• :nth-last-child(n) 匹配父元素下指定子元素，在所有子元素中排序第 n，从后向前数
• :nth-child(odd) 奇数
• :nth-child(even) 偶数
• :nth-child(3n+1)
• :first-child
• :last-child
• :only-child
• :nth-of-type(n) 匹配父元素下指定子元素，在同类子元素中排序第 n
• :nth-last-of-type(n) 匹配父元素下指定子元素，在同类子元素中排序第 n，从后向前数
• :nth-of-type(odd)
• :nth-of-type(even)
• :nth-of-type(3n+1)
• :first-of-type
• :last-of-type
• :only-of-type
• ::selection 选择被用户选取的元素部分
• :first-line 选择元素中的第一行
• :first-letter 选择元素中的第一个字符

CSS3 有哪些新特性 ?

• CSS3 实现圆角（border-radius:8px）
• 阴影（box-shadow:10px）
• 对文字加特效（text-shadow）
• 线性渐变（gradient）
• 旋转、缩放、定位、倾斜

 transform: rotate(9deg) scale(0.85,0.90) translate(0px,-30px) skew(-9deg,0deg); 

• 增加了更多的 CSS 选择器
• 多背景 rgba

一个满屏 品字布局 如何设计 ？

第一种方式

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>满屏品字布局</title>
    <style type="text/css">
        *{
            margin: 0;
            padding: 0;
        }
        html,body{
            height: 100%;/*此设置非常关键，因为默认的 body，HTML 高度为 0，所以后面设置的 div 的高度无法用百分比显示*/
        }       
        .header{
            height:50%; /*此步结合 html,body 高度为 100%，解决元素相对窗口的定位问题*/
            width: 50%;     
            background: #ccc;           
            margin:0 auto;
        }
        .main{
            width: 100%;
            height: 50%;
            background: #ddd;
        }
        .main .left,.main .right{
            float: left;/*采用 float 方式，对元素进行左右定位*/
            width:50%;/*此步解决元素相对窗口的定位问题*/
            height:100%;/*此步解决元素相对窗口的定位问题*/
            background: yellow;
        }
        .main .right{
            background: green;
        }
    </style>
</head>
<body>
<div class="header"></div>
<div class="main">
    <div class="left"></div>
    <div class="right"></div>
</div>
</body>
</html>

效果如下： 

为什么要初始化 CSS 样式 ?

因为浏览器的兼容问题，不同浏览器对有些标签的默认值是不同的，如果没对 CSS 初始化往往会出现浏览器之间的页面显示差异。
初始化样式会对 SEO 有一定的影响，但鱼和熊掌不可兼得，但力求影响最小的情况下初始化。

初始化 CSS 样式例子

html,
body {
  padding: 0; 
  margin: 0;
} 
...

请解释一下CSS3 的 Flexbox（弹性盒布局模型），以及适用场景 ？

http://www.ruanyifeng.com/blog/2015/07/flex-grammar.html

任何一个容器都可以指定为 Flex 布局，行内元素也可以使用 Flex 布局。

注意：设为 Flex 布局以后，子元素的 float、clear 和 vertical-align 属性将失效。

flex 布局最常用的是什么场景 ？

一般实现垂直居中是一件很麻烦的事，但 flex 布局轻松解决。

.demo {
  display: flex;            
  justify-content: center;                    
  align-items: center;
}

用纯 CSS 创建一个三角形的原理是什么？

把上、左、右三条边隐藏掉（颜色设为 transparent）

#demo {
 width: 0;
 height: 0;
 border-width: 20px;
 border-style: solid;
 border-color: transparent transparent red transparent;
}

absolute 的 containing block(容器块) 计算方式跟正常流有什么不同 ？

无论属于哪种，都要先找到其祖先元素中最近的 position 值不为 static 的元素，然后再判断：

• 若此元素为 inline 元素，则 containing block 为能够包含这个元素生成的第一个和最后一个 inline box 的 padding box (除 margin, border 外的区域) 的最小矩形；
• 否则，则由这个祖先元素的 padding box 构成。
• 如果都找不到，则为 initial containing block。

补充：

1. static / relative：简单说就是它的父元素的内容框（即去掉 padding 的部分）
2. absolute: 向上找最近的定位为 absolute / relative 的元素
3. fixed: 它的 containing block 一律为根元素(html / body)，根元素也是 initialcontaining block
    

对 BFC 规范(块级格式化上下文：blockformatting context)的理解 ？

W3C CSS 2.1 规范中的一个概念，它是一个独立容器，决定了元素如何对其内容进行定位，以及与其他元素的关系和相互作用。

• 一个页面是由很多个 Box 组成的，元素的类型和 display 属性，决定了这个 Box 的类型。
• 不同类型的 Box，会参与不同的 Formatting Context（决定如何渲染文档的容器），因此 Box 内的元素会以不同的方式渲染，也就是说 BFC 内部的元素和外部的元素不会互相影响。

用 position: absolute 跟用 float 有什么区别吗 ？

• 都是脱离标准流，只是 position: absolute 定位用的时候，位置可以给的更精确(想放哪就放哪)，而 float 用的更简洁，向右，左，两个方向浮动，用起来就一句代码。
• 还有就是 position: absolute 不管在哪个标签里，都可以定位到任意位置，毕竟 top，left，bottom，right 都可以给正值或负值；
• float 只是向左或向右浮动，不如 position: absolute 灵活，浮动后再想改变位置就要加各种 margin，padding 之类的通过间距的改变来改变位置，我自身觉得这样的话用起来不方便，也不太好。
• 但在菜单栏，或者一些图标的横向排列时，用起来特别方便，一个 float 就解决了，而且每个元素之间不会有任何间距(所以可以用 float 消除元素间的距离)；

canvas 与 svg 的区别 ？

• Canvas 是基于像素的即时模式图形系统，最适合较小的表面或较大数量的对象，Canvas 不支持鼠标键盘等事件。
• SVG 是基于形状的保留模式图形系统，更加适合较大的表面或较小数量的对象。
• Canvas 和 SVG 在修改方式上还存在着不同。绘制 Canvas 对象后，不能使用脚本和 CSS 对它进行修改。因为 SVG 对象是文档对象模型的一部分，所以可以随时使用脚本和 CSS 修改它们。

现在对两种技术做对比归纳如下：

Canvas

1. 依赖分辨率
2. 不支持事件处理器
3. 弱的文本渲染能力
4. 能够以 .png 或 .jpg 格式保存结果图像
5. 最适合图像密集型的游戏，其中的许多对象会被频繁重绘

SVG

1. 不依赖分辨率
2. 支持事件处理器
3. 最适合带有大型渲染区域的应用程序（比如谷歌地图）
4. 复杂度高会减慢渲染速度（任何过度使用 DOM 的应用都不快）
5. 不适合游戏应用

svg 与 canvas 的区别 ？

• svg 绘制出来的每一个图形的元素都是独立的 DOM 节点，能够方便的绑定事件或用来修改，而 canvas 输出的是一整幅画布；
• svg 输出的图形是矢量图形，后期可以修改参数来自由放大缩小，不会是真和锯齿。而 canvas 输出标量画布，就像一张图片一样，放大会失真或者锯齿。

何时应当时用 padding 和 margin ？

何时应当使用 margin

• 需要在 border 外侧添加空白时。
• 空白处不需要背景（色）时。
• 上下相连的两个盒子之间的空白，需要相互抵消时。
  如 15px + 20px 的 margin，将得到 20px 的空白。

何时应当使用 padding

• 需要在 border 内测添加空白时。
• 空白处需要背景（色）时。
• 上下相连的两个盒子之间的空白，希望等于两者之和时。
  如 15px + 20px 的 padding，将得到 35px 的空白。

个人认为：margin 是用来隔开元素与元素的间距；padding 是用来隔开元素与内容的间隔，让内容（文字）与（包裹）元素之间有一段 呼吸距离。

文字在超出长度时，如何实现用省略号代替 ? 超长长度的文字在省略显示后，如何在鼠标悬停时，以悬浮框的形式显示出全部信息 ?

注意：设置 width，overflow: hidden, white-space: nowrap (规定段落中的文本不进行换行), text-overflow: ellipsis，四个属性缺一不可。这种写法在所有的浏览器中都能正常显示。

CSS 里的 visibility 属性有个 collapse 属性值 ？在不同浏览器下有什么区别 ？

collapse

• 当在表格元素中使用时，此值可删除一行或一列，但是它不会影响表格的布局，被行或列占据的空间会留给其他内容使用。

• 如果此值被用在其他的元素上，会呈现为 hidden。

• 当一个元素的 visibility 属性被设置成 collapse 值后，对于一般的元素，它的表现跟 hidden 是一样的。

• chrome中，使用 collapse 值和使用 hidden 没有区别。

• firefox，opera 和 IE，使用 collapse 值和使用 display：none 没有什么区别。

position 跟 display、overflow、float 这些特性相互叠加后会怎么样 ？

• display 属性规定元素应该生成的框的类型；
• position 属性规定元素的定位类型；
• float 属性是一种布局方式，定义元素在哪个方向浮动。
• 类似于优先级机制：position：absolute / fixed 优先级最高，有他们在时，float 不起作用，display 值需要调整。float 或者 absolute 定位的元素，只能是块元素或表格。

对 BFC 规范(块级格式化上下文：block formatting context) 的理解 ？

BFC 规定了内部的 Block Box 如何布局。

定位方案：

• 内部的 Box 会在垂直方向上一个接一个放置。
• Box 垂直方向的距离由 margin 决定，属于同一个 BFC 的两个相邻 Box 的 margin 会发生重叠。
• 每个元素的 margin box 的左边，与包含块 border box 的左边相接触。
• BFC 的区域不会与 float box 重叠。
• BFC 是页面上的一个隔离的独立容器，容器里面的子元素不会影响到外面的元素。

计算 BFC 的高度时，浮动元素也会参与计算。

满足下列条件之一就可触发 BFC：

• 1、根元素，即 html
• 2、float 的值不为 none（默认）
• 3、overflow 的值不为 visible（默认）
• 4、display 的值为 inline-block、table-cell、table-caption
• 5、position 的值为 absolute 或 fixed

浏览器是怎样解析 CSS 选择器的 ？

• CSS 选择器的解析是从右向左解析的。
• 若从左向右的匹配，发现不符合规则，需要进行回溯，会损失很多性能。
• 若从右向左匹配，先找到所有的最右节点，对于每一个节点，向上寻找其父节点直到找到根元素或满足条件的匹配规则，则结束这个分支的遍历。
• 两种匹配规则的性能差别很大，是因为从右向左的匹配在第一步就筛选掉了大量的不符合条件的最右节点（叶子节点），而从左向右的匹配规则的性能都浪费在了失败的查找上面。
• 而在 CSS 解析完毕后，需要将解析的结果与 DOM Tree 的内容一起进行分析建立一棵 Render Tree，最终用来进行绘图。
• 在建立 Render Tree 时（WebKit 中的「Attachment」过程），浏览器就要为每个 DOM Tree 中的元素根据 CSS 的解析结果（Style Rules）来确定生成怎样的 Render Tree。

元素竖向的百分比设定是相对于容器的高度吗 ？

当按百分比设定一个元素的宽度时，它是相对于父容器的宽度计算的。

全屏滚动的原理是什么 ？用到了 CSS 的哪些属性 ？

原理

• 有点类似于轮播，整体的元素一直排列下去，假设有 5 个需要展示的全屏页面，那么高度是 500%，只是展示 100%，剩下的可以通过 transform 进行 y 轴定位，也可以通过 margin-top 实现。
• overflow：hidden；transition：all 1000ms ease；

什么是响应式设计 ？响应式设计的基本原理是什么 ？如何兼容低版本的 IE ？

• 响应式网站设计( Responsive Web design ) 是一个网站能够兼容多个终端，而不是为每一个终端做一个特定的版本。
• 基本原理是通过媒体查询检测不同的设备屏幕尺寸做处理。
• 页面头部必须有 meta 声明的 viewport。

<meta name="viewport" content="” width="device-width" initial-scale="1" maximum-scale="1" user-scalable="no"/>

视差滚动效果 ？

视差滚动（Parallax Scrolling）通过在网页向下滚动的时候，控制背景的移动速度比前景的移动速度慢来创建出令人惊叹的 3D 效果。

• CSS3 实现。
  优点：开发时间短、性能和开发效率比较好，缺点是不能兼容到低版本的浏览器
• jQuery 实现。
  通过控制不同层滚动速度，计算每一层的时间，控制滚动效果。优点：能兼容到各个版本的，效果可控性好。缺点：开发起来对制作者要求高。
• 插件实现方式。
  例如：parallax-scrolling，兼容性十分好。

::before 和 :after 中双冒号和单冒号有什么区别 ？解释一下这 2 个伪元素的作用

• 单冒号 (:) 用于 CSS3 伪类，双冒号 (::) 用于 CSS3 伪元素。
• ::before 就是以一个子元素的存在，定义在元素主体内容之前的一个伪元素。并不存在于 dom 之中，只存在在页面之中。

:before 和 :after 这两个伪元素，是在 CSS2.1 里新出现的。
起初，伪元素的前缀使用的是单冒号语法，但随着 Web 的进化，在 CSS3 的规范里，伪元素的语法被修改成使用双冒号，成为 ::before、 ::after 。

怎么让 Chrome 支持小于 12px 的文字 ？

p {
  font-size: 10px;
  -webkit-transform: scale(0.8);  // 0.8 是缩放比例
} 

让页面里的字体变清晰，变细用 CSS 怎么做 ？

-webkit-font-smoothing 在 window 系统下没有起作用，但是在 IOS 设备上起作用 -webkit-font-smoothing：antialiased 是最佳的，灰度平滑。

如果需要手动写动画，你认为最小时间间隔是多久，为什么 ？

多数显示器默认频率是 60Hz，即 1 秒刷新 60 次，所以理论上最小间隔为：1/60＊1000ms ＝ 16.7ms。

有一个高度自适应的 div，里面有两个 div，一个高度 100px，如何让另一个填满剩下的高度 ？

• 外层 div 使用 position：relative；
• 高度要求自适应的 div 使用 position: absolute; top: 100px; bottom: 0; left: 0

style 标签写在 body 后与 body 前有什么区别？

页面加载自上而下，当然是先加载样式。

写在 body 标签后，由于浏览器以逐行方式对 HTML 文档进行解析，当解析到写在尾部的样式表（外联或写在style标签）会导致浏览器停止之前的渲染，等待加载且解析样式表完成之后重新渲染，在 windows 的 IE 下可能会出现 FOUC 现象（即样式失效导致的页面闪烁问题）

阐述一下CSS Sprites

将一个页面涉及到的所有图片都包含到一张大图中去，然后利用 CSS 的 background-image，background-repeat，background-position 的组合进行背景定位。

利用 CSS Sprites 能很好地减少网页的 http 请求，从而大大的提高页面的性能；
CSS Sprites 能减少图片的字节。

用 css 实现左侧宽度自适应，右侧固定宽度 ？

1、标准浏览器的方法

当然，以不折腾人为标准的 w3c 标准早就为我们提供了制作这种自适应宽度的标准方法。

• 把 container 设为 display: table 并指定宽度 100%；
• 然后把 main + sidebar 设为 display: table-cell;
• 然后只给 sidebar 指定一个宽度，那么 main 的宽度就变成自适应了。

代码很少，而且不会有额外标签。不过这是 IE7 及以下都无效的方法。

.container {
    display: table;
    width: 100%;
}
.main {
    display: table-cell;
}
.sidebar {
    display: table-cell;
    width: 300px;
}

2、固定区域浮动，自适应区域不设置宽度但设置 margin

.container {
    overflow: hidden;
    *zoom: 1;
}
.sidebar {
    float: right;
    width: 300px;
    background: #333;
}
.main {
    margin-right: 320px;
    background: #666;
}
.footer {
    margin-top: 20px;
    background: #ccc;
}

其中，sidebar 让它浮动，并设置了一个宽度；而 main 没有设置宽度。

大家要注意 html 中必须使用 div 标签，不要妄图使用什么 p 标签来达到目的。因为 div 有个默认属性，即如果不设置宽度，那它会自动填满它的父标签的宽度。这里的 main 就是例子。

当然我们不能让它填满了，填满了它就不能和 sidebar 保持同一行了。我们给它设置一个 margin。由于 sidebar 在右边，所以我们设置 main 的 margin-right 值，值比 sidebar 的宽度大一点点——以便区分它们的范围，例子中是 320。

假设 main 的默认宽度是 100%，那么它设置了 margin 后，它的宽度就变成了 100% - 320，此时 main 发现自己的宽度可以与 sidebar 挤在同一行了，于是它就上来了。
而宽度 100% 是相对于它的父标签来的，如果我们改变了它父标签的宽度，那 main 的宽度也就会变——比如我们把浏览器窗口缩小，那 container 的宽度就会变小，而 main 的宽度也就变小，但它的实际宽度 100% - 320 始终是不会变的。

这个方法看起来很完美，只要我们记得清除浮动(这里我用了最简单的方法)，那 footer 也不会错位。而且无论 main 和 sidebar 谁更长，都不会对布局造成影响。

但实际上这个方法有个很老火的限制——html 中 sidebar 必须在 main 之前！
但我需要 sidebar 在 main 之后！因为我的 main 里面才是网页的主要内容，我不想主要内容反而排在次要内容后面。
但如果 sidebar 在 main 之后，那上面的一切都会化为泡影。

3、固定区域使用定位，自适应区域不设置宽度，但设置 margin

.container {
    position: relative;
}
.sidebar {
    position: absolute;
    top: 0;
    right: 0;
    width: 300px;
    background: #333;
}
.main {
    margin-right: 320px;
    background: #666;
}

咦，好像不对，footer 怎么还是在那儿呢？怎么没有自动往下走呢？footer 说——我不给绝对主义者让位！
其实这与 footer 无关，而是因为 container 对 sidebar 的无视造成的——你再长，我还是没感觉。
看来这种定位方式只能满足 sidebar 自己，但对它的兄弟们却毫无益处。

4、左边浮动，右边 overflow: hidden;

*{margin:0; padding: 0;}
html,body{
   height: 100%;/*高度百分百显示*/
}
#left{
    width: 300px;
    height: 100%;
    background-color: #ccc;
    float: left;
}
#right{
    height: 100%;
    overflow: hidden;
    background-color: #eee;
}

这个方法，我利用的是创建一个新的 BFC（块级格式化上下文）来防止文字环绕的原理来实现的。

BFC 就是一个相对独立的布局环境，它内部元素的布局不受外面布局的影响。
它可以通过以下任何一种方式来创建： 

• float 的值不为 none 
• position 的值不为 static 或者 relative 
• display 的值为 table-cell , table-caption , inline-block , flex , 或者 inline-flex 中的其中一个 
• overflow 的值不为 visible

关于 BFC，在 w3c 里是这样描述的：在 BFC 中，每个盒子的左外边框紧挨着 包含块 的 左边框 （从右到左的格式化时，则为右边框紧挨）。
即使在浮动里也是这样的（尽管一个包含块的边框会因为浮动而萎缩），除非这个包含块的内部创建了一个新的 BFC。
这样，当我们给右侧的元素单独创建一个 BFC 时，它将不会紧贴在包含块的左边框，而是紧贴在左元素的右边框。

问：浮动的原理和工作方式，会产生什么影响呢，要怎么处理 ？

工作方式：浮动元素脱离文档流，不占据空间。浮动元素碰到包含它的边框或者浮动元素的边框停留。

影响

• 浮动会导致父元素无法被撑开，影响与父元素同级的元素。
• 与该浮动元素同级的非浮动元素，如果是块级元素，会移动到该元素下方，而块级元素内部的行内元素会环绕浮动元素；而如果是内联元素则会环绕该浮动元素。
• 与该元素同级的浮动元素，对于同一方向的浮动元素(同级)，两个元素将会跟在碰到的浮动元素后；而对于不同方向的浮动元素，在宽度足够时，将分别浮动向不同方向，在宽度不同是将导致一方换行(换行与 HTML 书写顺序有关，后边的将会浮动到下一行)。
• 浮动元素将被视作为块元素。
• 而浮动元素对于其父元素之外的元素，如果是非浮动元素，则相当于忽视该浮动元素，如果是浮动元素，则相当于同级的浮动元素。
• 而常用的清除浮动的方法，则如使用空标签，overflow，伪元素等。

在使用基于浮动设计的 CSS 框架时，自会提供清除的方法，个人并不习惯使用浮动进行布局。

对 CSS Grid 布局的使用

5 分钟学会 CSS Grid 布局

rem、em、px、vh 与 vw 的区别 ？

一、 rem 的特点

1. rem 的大小是根据 html 根目录下的字体大小进行计算的。
2. 当我们改变根目录下的字体大小的时候，下面字体都改变。
3. rem 不仅可以设置字体的大小，也可以设置元素宽、高等属性。
4. rem 是 CSS3 新增的一个相对单位（root em，根em），这个单位与 em 区别在于使用 rem 为元素设定字体大小时，仍然是相对大小，但相对的只是 HTML 根元素。

这个单位可谓集相对大小和绝对大小的优点于一身，通过它既可以做到只修改根元素就成比例地调整所有字体大小，又可以避免字体大小逐层复合的连锁反应。
目前，除了 IE8 及更早版本外，所有浏览器均已支持 rem。
对于不支持它的浏览器，应对方法也很简单，就是多写一个绝对单位的声明。这些浏览器会忽略用 rem 设定的字体大小。

二、px 特点

1. px 像素（Pixel）。相对长度单位。像素 px 是相对于显示器屏幕分辨率而言的。

三、em 特点 

1. em 的值并不是固定的；
2. em 会继承父级元素的字体大小。
3. em 是相对长度单位。当前对行内文本的字体尺寸未被人为设置，相对于当前对象内文本的字体尺寸。如则相对于浏览器的默认字体尺寸。
4. 任意浏览器的默认字体高都是 16px。

所有未经调整的浏览器一般都符合: 1em = 16px。那么 12px = 0.75em，10px = 0.625em。
为了简化 font-size 的换算，需要在 css 中的 body 选择器中声明 Fontsize = 62.5%，这就使 em 值变为 16px*62.5%=10px, 这样 12px = 1.2em, 10px = 1em, 也就是说只需要将你的原来的 px 数值除以 10，然后换上 em 作为单位就行了。

四、vh 与 vw

视口

• 在桌面端，指的是浏览器的可视区域；
• 在移动端，它涉及 3个 视口：Layout Viewport（布局视口），Visual Viewport（视觉视口），Ideal Viewport（理想视口）。
• 视口单位中的 “视口”，桌面端指的是浏览器的可视区域；移动端指的就是 Viewport 中的 Layout Viewport。

vh / vw 与 %

比如：浏览器视口尺寸为 370px，那么 1vw = 370px * 1% = 6.5px (浏览器会四舍五入向下取 7)

vh / vw 与 % 区别

不过由于 vw 和 vh 是 css3 才支持的长度单位，所以在不支持 css3 的浏览器中是无效的。

什么叫优雅降级和渐进增强 ？

• 渐进增强 progressive enhancement：针对低版本浏览器进行构建页面，保证最基本的功能，然后再针对高级浏览器进行效果、交互等改进和追加功能达到更好的用户体验。
• 优雅降级 graceful degradation：一开始就构建完整的功能，然后再针对低版本浏览器进行兼容。

区别

• 优雅降级是从复杂的现状开始，并试图减少用户体验的供给；
• 渐进增强则是从一个非常基础的，能够起作用的版本开始，并不断扩充，以适应未来环境的需要；
• 降级（功能衰减）意味着往回看；而渐进增强则意味着朝前看，同时保证其根基处于安全地带。

width 和 height 的百分比是相对谁讲的 ？margin 和 padding 呢？

• width 是相对于直接父元素的 width
• height 是相对于直接父元素的 height
• padding 是相对于直接父元素的 width
• margin 是相对于直接父元素的 margin

<style>
    #wrapper {
        width: 500px;
        height: 800px;
        background-color: #ccc;
    }
    .parent {
        width: 300px;
        height: 400px;
        background-color: yellow;
    }
    .son {
        /* 90*40 */
        width: 30%;
        height: 10%;
        /* 30 30 */
        padding-left: 10%;
        margin-left: 10%;
        background-color: green;
    }
</style>
<div id="wrapper">
    <div class="parent">
        <div class="son">
        </div>
    </div>
</div>

相关文章：

• transform，transition，animation，keyframes区别
• width 和 height 的百分比是相对谁讲的 ？margin 和 padding 呢？
• 彻底搞懂 CSS 层叠上下文、层叠等级、层叠顺序、z-index

4. JavaScript

常见的浏览器内核有哪些 ？

• Trident 内核：IE, 360，搜狗浏览器 MaxThon、TT、The World,等。[又称 MSHTML]
• Gecko 内核：火狐，FF，MozillaSuite / SeaMonkey 等
• Presto 内核：Opera7 及以上。[Opera 内核原为：Presto，现为：Blink]
• Webkit 内核：Safari，Chrome 等。 [ Chrome 的：Blink（WebKit 的分支）]

try/catch 无法捕获 promise.reject 的问题

try..catch 结构，它只能是同步的，无法用于异步代码模式。

https://segmentfault.com/q/1010000014905440

error 事件的事件处理程序

https://developer.mozilla.org/zh-CN/docs/Web/API/GlobalEventHandlers/onerror

一个简易版的 Function.prototype.bind 实现

Function.prototype.bind = function (context) {
    var self = this;
    return function () {
        return self.apply(context, arguments);
    };
};

var obj = {
    name: '前端架构师'
};
var func = function () {
    console.log(this.name);
}.bind(obj);
func();

• 【JavaScript】Function.prototype.bind 实现原理

call、apply、bind

1. 怎么利用 call、apply 来求一个数组中最大或者最小值 ?
2. 如何利用 call、apply 来做继承 ?
3. apply、call、bind 的区别和主要应用场景 ?

• call 跟 apply 的用法几乎一样，唯一的不同就是传递的参数不同，call 只能一个参数一个参数的传入。
• apply 则只支持传入一个数组，哪怕是一个参数也要是数组形式。最终调用函数时候这个数组会拆成一个个参数分别传入。
• 至于 bind 方法，他是直接改变这个函数的 this 指向并且返回一个新的函数，之后再次调用这个函数的时候 this 都是指向 bind 绑定的第一个参数。
• bind 传参方式跟 call 方法一致。

适用场景：

求一个数组中最大或者最小值

// 如果一个数组我们已知里面全都是数字，想要知道最大的那个数，由于 Array 没有 max 方法，Math 对象上有
// 我们可以根据 apply 传递参数的特性将这个数组当成参数传入
// 最终 Math.max 函数调用的时候会将 apply 的数组里面的参数一个一个传入，恰好符合 Math.max 的参数传递方式
// 这样变相的实现了数组的 max 方法。min 方法也同理
const arr = [1,2,3,4,5,6]
const max = Math.max.apply(null, arr)
console.log(max)    // 6

参数都会排在之后

// 如果你想将某个函数绑定新的`this`指向并且固定先传入几个变量可以在绑定的时候就传入，之后调用新函数传入的参数都会排在之后
const obj = {}
function test(...args) { console.log(args) }
const newFn = test.bind(obj, '静态参数1', '静态参数2')
newFn('动态参数3', '动态参数4')

利用 call 和 apply 做继承

function Animal(name){
  this.name = name;
  this.showName = function(){
    console.log(this.name);
  }
}

function Cat(name){
  Animal.call(this, name);
}

// Animal.call(this) 的意思就是使用 this 对象代替 Animal 对象，那么
// Cat 中不就有 Animal 的所有属性和方法了吗，Cat 对象就能够直接调用 Animal 的方法以及属性了
var cat = new Cat("TONY");
cat.showName(); //TONY

将伪数组转化为数组（含有 length 属性的对象，dom 节点, 函数的参数 arguments）

// case1: dom节点：
<div class="div1">1</div>
<div class="div1">2</div>
<div class="div1">3</div>

let div = document.getElementsByTagName('div');
console.log(div); // HTMLCollection(3) [div.div1, div.div1, div.div1] 里面包含length属性
let arr2 = Array.prototype.slice.call(div);
console.log(arr2); // 数组 [div.div1, div.div1, div.div1]


//case2：fn 内的 arguments
function fn10() {
    return Array.prototype.slice.call(arguments);
}
console.log(fn10(1,2,3,4,5)); // [1, 2, 3, 4, 5]


// case3: 含有 length 属性的对象
let obj4 = {
    0: 1,
    1: 'thomas',
    2: 13,
    length: 3 // 一定要有length属性
};
console.log(Array.prototype.slice.call(obj4)); // [1, "thomas", 13]

判断变量类型

let arr1 = [1,2,3];
let str1 = 'string';
let obj1 = { name: 'thomas' };
//
function isArray(obj) {
  return Object.prototype.toString.call(obj) === '[object Array]';
}
console.log(fn1(arr1)); // true

// 判断类型的方式，这个最常用语判断 array 和 object ，null( 因为 typeof null 等于 object )
console.log(Object.prototype.toString.call(arr1)); // [object Array]
console.log(Object.prototype.toString.call(str1)); // [object String]
console.log(Object.prototype.toString.call(obj1)); // [object Object]
console.log(Object.prototype.toString.call(null)); // [object Null]

总结：

1. 当我们使用一个函数需要改变 this 指向的时候才会用到 call apply bind
2. 如果你要传递的参数不多，则可以使用 fn.call(thisObj, arg1, arg2 ...)
3. 如果你要传递的参数很多，则可以用数组将参数整理好调用 fn.apply(thisObj, [arg1, arg2 ...])
4. 如果你想生成一个新的函数长期绑定某个函数给某个对象使用，则可以使用 const newFn = fn.bind(thisObj); newFn(arg1, arg2...)

手写 bind

Function.prototype.myBind = function(context, ...args) {
  // 设置 fn 为调用 myCall 的方法
  const fn = this
  args = args ? args : []

  // 设置返回的一个新方法
  const result = function(...newFnArgs) {

    // 如果是通过 new 调用的，绑定 this 为实例对象
    if (this instanceof result) {
      fn.apply(this, [...args, ...newFnArgs]);
    } else { // 否则普通函数形式绑定 context
      fn.apply(context, [...args, ...newFnArgs]);
    }
  }

  // 绑定原型链
  result.prototype = Object.create(fn.prototype);

  // 返回结果
  return result;
};

this.a = 1;

const fn = function() {
  this.a = 2;
  console.log(this.a);
}

fn.myBind(fn);
fn();

实现 apply

Function.prototype.myApply = function (context, args) {
    //这里默认不传就是给window,也可以用es6给参数设置默认参数
    context = context || window
    args = args ? args : []
    //给context新增一个独一无二的属性以免覆盖原有属性
    const key = Symbol()
    context[key] = this
    //通过隐式绑定的方式调用函数
    const result = context[key](...args)
    //删除添加的属性
    delete context[key]
    //返回函数调用的返回值
    return result
}

实现 call

//传递参数从一个数组变成逐个传参了,不用...扩展运算符的也可以用arguments代替
Function.prototype.myCall = function (context, ...args) {
    //这里默认不传就是给window,也可以用es6给参数设置默认参数
    context = context || window
    args = args ? args : []
    //给context新增一个独一无二的属性以免覆盖原有属性
    const key = Symbol()
    context[key] = this
    //通过隐式绑定的方式调用函数
    const result = context[key](...args)
    //删除添加的属性
    delete context[key]
    //返回函数调用的返回值
    return result
}

参考文章：

• 手写 bind, apply, call
• call、apply、bind 的区别
• 聊一聊 call、apply、bind 的区别

彻底弄清 js 继承的几种实现方式
理解 js 继承的 6 种方式

mouseenter 和 mouseover 的区别 

• 不论鼠标指针穿过被选元素或其子元素，都会触发 mouseover 事件，对应 mouseout。
• 只有在鼠标指针穿过被选元素时，才会触发 mouseenter 事件，对应 mouseleave。

用正则表达式匹配字符串，以字母开头，后面是数字、字符串或者下划线，长度为 9 - 20 

var re = new RegExp("^[a-zA-Z][a-zA-Z0-9_]{8,19}$");

js 字符串两边截取空白的 trim 的原型方法的实现

// 删除左右两端的空格
function trim(str){
 return str.replace(/(^\s*)|(\s*$)/g, "");
}
// 删除左边的空格 /(^\s*)/g
// 删除右边的空格 /(\s*$)/g

介绍一下你对浏览器内核的理解 ?

内核主要分成两部分：渲染引擎(layout engineer 或 Rendering Engine) 和 JS 引擎。

渲染引擎

负责取得网页的内容（HTML、XML、图像等等）、整理讯息（例如加入 CSS 等），以及计算网页的显示方式，然后会输出至显示器或打印机。
浏览器的内核的不同对于网页的语法解释会有不同，所以渲染的效果也不相同。
所有网页浏览器、电子邮件客户端以及其它需要编辑、显示网络内容的应用程序都需要内核。

JS 引擎

解析和执行 javascript 来实现网页的动态效果。

最开始渲染引擎和 JS 引擎并没有区分的很明确，后来 JS 引擎越来越独立，内核就倾向于只指渲染引擎。

哪些常见操作会造成内存泄漏 ？

内存泄漏指任何对象在您不再拥有或需要它之后仍然存在。

垃圾回收器定期扫描对象，并计算引用了每个对象的其他对象的数量。如果一个对象的引用数量为 0（没有其他对象引用过该对象），或对该对象的惟一引用是循环的，那么该对象的内存即可回收。

• setTimeout 的第一个参数使用字符串而非函数的话，会引发内存泄漏。
• 闭包、控制台日志、循环（在两个对象彼此引用且彼此保留时，就会产生一个循环）。

线程与进程的区别 ？

• 一个程序至少有一个进程，一个进程至少有一个线程。
• 线程的划分尺度小于进程，使得多线程程序的并发性高。
• 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。

• 每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
• 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。
  但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

eval() 函数有什么用 ？

eval() 函数可计算某个字符串，并执行其中的的 JavaScript 代码。

实现一个方法，使得：add(2, 5) 和 add(2)(5) 的结果都为 7

var add = function (x, r) {
	if (arguments.length === 1) {
		return function (y) { return x + y; };
	} else {
		return x + r;
	}
};
console.log(add(2)(5));  // 7
console.log(add(2,5));  // 7

alert(1 && 2) 和 alert(1 || 0) 的结果是 ？

alert(1 &&2 ) 的结果是 2

• 只要 “&&” 前面是 false，无论 “&&” 后面是 true 还是 false，结果都将返 “&&” 前面的值;
• 只要 “&&” 前面是 true，无论 “&&” 后面是 true 还是 false，结果都将返 “&&” 后面的值;

alert(0 || 1) 的结果是 1

• 只要 “||” 前面为 false，不管 “||” 后面是 true 还是 false，都返回 “||” 后面的值。
• 只要 “||” 前面为 true，不管 “||” 后面是 true 还是 false，都返回 “||” 前面的值。

只要记住 0 与 任何数都是 0，其他反推。

下面的输出结果是 ？

var out = 25,
   inner = {
        out: 20,
        func: function () {
            var out = 30;
            return this.out;
        }
    };
console.log((inner.func, inner.func)());
console.log(inner.func());
console.log((inner.func)());
console.log((inner.func = inner.func)());

结果：25，20，20，25

代码解析：这道题的考点分两个

1. 作用域
2. 运算符（赋值预算，逗号运算）

先看第一个输出：25，因为 ( inner.func, inner.func ) 是进行逗号运算符，逗号运算符就是运算前面的 ”,“ 返回最后一个，举个栗子

var i = 0, j = 1, k = 2;
console.log((i++, j++, k)) // 返回的是 k 的值 2 ，如果写成 k++ 的话  这里返回的就是 3
console.log(i); // 1
console.log(j); // 2
console.log(k); // 2   

回到原题 ( inner.func, inner.func ) 就是返回 inner.func ，而 inner.func 只是一个匿名函数

function () {
    var out = 30;
    return this.out;
}

而且这个匿名函数是属于 window 的，则变成了

(function () {
    var out = 30;
    return this.out;
})()

此刻的 this => window

所以 out 是 25。

第二和第三个 console.log 的作用域都是 inner，也就是他们执行的其实是 inner.func();
inner 作用域中是有 out 变量的，所以结果是 20。

第四个 console.log 考查的是一个等号运算 inner.func = inner.func ，其实返回的是运算的结果，
举个栗子

var a = 2, b = 3;
console.log(a = b) // 输出的是 3

所以 inner.func = inner.func 返回的也是一个匿名函数

function () {
    var out = 30;
    return this.out;
}

此刻，道理就和第一个 console.log 一样了，输出的结果是 25。

下面程序输出的结果是 ？

if (!("a" in window)) {
    var a = 1;
}
alert(a);

代码解析：如果 window 不包含属性 a，就声明一个变量 a，然后赋值为 1。

你可能认为 alert 出来的结果是 1，然后实际结果是 “undefined”。

要了解为什么，需要知道 JavaScript 里的 3 个概念。

首先，在 es6 之前，所有的全局变量都是 window 的属性，语句 var a = 1; 等价于 window.a = 1;
你可以用如下方式来检测全局变量是否声明："变量名称" in window。

第二，所有的变量声明都在范围作用域的顶部，看一下相似的例子：

alert("b" in window);
var b;

此时，尽管声明是在 alert 之后，alert 弹出的依然是 true，这是因为 JavaScript 引擎首先会扫描所有的变量声明，然后将这些变量声明移动到顶部，最终的代码效果是这样的：

var a;
alert("a" in window);

这样看起来就很容易解释为什么 alert 结果是 true 了。

第三，你需要理解该题目的意思是，变量声明被提前了，但变量赋值没有，因为这行代码包括了变量声明和变量赋值。

你可以将语句拆分为如下代码：

var a;    //声明
a = 1;    //初始化赋值

当变量声明和赋值在一起用的时候，JavaScript 引擎会自动将它分为两部以便将变量声明提前，
不将赋值的步骤提前，是因为他有可能影响代码执行出不可预期的结果。

所以，知道了这些概念以后，重新回头看一下题目的代码，其实就等价于：

var a;
if (!("a" in window)) {
    a = 1;
}
alert(a);

这样，题目的意思就非常清楚了：首先声明 a，然后判断 a 是否在存在，如果不存在就赋值为1，很明显 a 永远在 window 里存在，这个赋值语句永远不会执行，所以结果是 undefined。

提前这个词语显得有点迷惑了，你可以理解为：预编译。

下面程序输出的结果是 ？

var a = 1;
var b = function a(x) {
  x && a(--x);
};
alert(a);

这个题目看起来比实际复杂，alert 的结果是 1。

这里依然有 3 个重要的概念需要我们知道。

• 首先，第一个是 变量声明在进入执行上下文就完成了；
• 第二个概念就是函数声明也是提前的，所有的函数声明都在执行代码之前都已经完成了声明，和变量声明一样。

澄清一下，函数声明是如下这样的代码：

function functionName(arg1, arg2){
    //函数体
}

如下不是函数，而是函数表达式，相当于变量赋值：

var functionName = function(arg1, arg2){
       //函数体
   };

澄清一下，函数表达式没有提前，就相当于平时的变量赋值。

• 第三需要知道的是，函数声明会覆盖变量声明，但不会覆盖变量赋值。

为了解释这个，我们来看一个例子：

function value(){
    return 1;
}
var value;
alert(typeof value);    //"function"

尽管变量声明在下面定义，但是变量 value 依然是 function，也就是说这种情况下，函数声明的优先级高于变量声明的优先级，但如果该变量 value 赋值了，那结果就完全不一样了：

function value(){
    return 1;
}
var value = 1;
alert(typeof value);    //"number"

该 value 赋值以后，变量赋值初始化就覆盖了函数声明。

重新回到题目，这个函数其实是一个有名函数表达式，函数表达式不像函数声明一样可以覆盖变量声明，但你可以注意到，变量 b 是包含了该函数表达式，而该函数表达式的名字是 a。

不同的浏览器对 a 这个名词处理有点不一样，在 IE 里，会将 a 认为函数声明，所以它被变量初始化覆盖了，就是说如果调用 a(–x) 的话就会出错，而其它浏览器在允许在函数内部调用 a(–x)，因为这时候 a 在函数外面依然是数字。
基本上，IE 里调用 b(2) 的时候会出错，但其它浏览器则返回 undefined。

理解上述内容之后，该题目换成一个更准确和更容易理解的代码应该像这样：

var a = 1,
    b = function(x) {
      x && b(--x);
    };
alert(a);

这样的话，就很清晰地知道为什么 alert 的总是 1 了。

下面程序输出的结果是 ？

function a(x) {
    return x * 2;
}
var a;
alert(a);

alert 的值是下面的函数

function a(x) {
    return x * 2;
}

这个题目比较简单：即函数声明和变量声明的关系和影响，遇到同名的函数声明，不会重新定义。

下面程序输出的结果是 ？

function b(x, y, a) {
        arguments[2] = 10;
        alert(a);
}
b(1, 2, 3);

结果为 10。

活动对象是在进入函数上下文时刻被创建的，它通过函数的 arguments 属性初始化。

三道判断输出的题都是经典的题

var a = 4;
function b() {
  a = 3;
  console.log(a);
  function a(){};
}
b();

明显输出是 3，因为里面修改了 a 这个全局变量，那个 function a(){} 是用来干扰的，虽然函数声明会提升，就被 a 给覆盖掉了，这是我的理解。

不记得具体的，就类似如下

var baz = 3;
var bazz ={
  baz: 2,
  getbaz: function() {
    return this.baz
  }
}
console.log(bazz.getbaz())
var g = bazz.getbaz;
console.log(g()) ;

第一个输出是 2，第二个输出是 3。

这题考察的就是 this 的指向，函数作为对象本身属性调用的时候，this 指向对象，作为普通函数调用的时候，就指向全局了。

还有下面的题：

var arr = [1,2,3,4,5];
for(var i = 0; i < arr.length; i++){
  arr[i] = function(){
    alert(i)
  }
}
arr[3]();

典型的闭包，弹出 5 。

解释清楚 null 和 undefined

null 用来表示尚未存在的对象，常用来表示函数企图返回一个不存在的对象。  null 表示"没有对象"，即该处不应该有值。
null 典型用法是： 

• 作为函数的参数，表示该函数的参数不是对象。 
• 作为对象原型链的终点。

当声明的变量还未被初始化时，变量的默认值为 undefined。 undefined 表示"缺少值"，就是此处应该有一个值，但是还没有定义。 

• 变量被声明了，但没有赋值时，就等于 undefined。 
• 调用函数时，应该提供的参数没有提供，该参数等于 undefined。 
• 对象没有赋值的属性，该属性的值为 undefined。 
• 函数没有返回值时，默认返回 undefined。

未定义的值和定义未赋值的为 undefined，null 是一种特殊的 object，NaN 是一种特殊的 number。

讲一下 1 和 Number(1) 的区别*

• 1 是一个原始定义好的 number 类型；
• Number(1) 是一个函数类型，是我们自己声明的一个函数（方法）。

讲一下 prototype 是什么东西，原型链的理解，什么时候用 prototype ？

prototype 是函数对象上面预设的对象属性。

深入JavaScript系列（六）：原型与原型链

实现 add(1)(2)(3) = 6

这题考察的是柯里化,做这题之前呢,我们得知道柯里化的概念:

柯里化就是把接收多个参数的函数变换成接收一个单一参数(最初函数的第一个参数)的函数。

const curry = (fn, ...args) => 
            args.length < fn.length 
            // 参数长度不足时,重新柯里化函数,等待接受新参数
            ? (...arguments) => curry(fn, ...args, ...arguments)
            // 函数长度满足时,执行函数
             : fn(...args);

function sumFn(a, b, c){
    return a + b + c;
}
var sum = curry(sumFn);
console.log(sum(1)(2)(3)); //6

script 标签的 defer 和 async

• 一个普通的 <script> 标签的加载和解析都是同步的，会阻塞 DOM 的渲染，这也就是我们经常会把 <script> 写在 <body>底部的原因之一，为了防止加载资源而导致的长时间的白屏。
• 另一个原因是 js 可能会进行 DOM 操作，所以要在 DOM 全部渲染完后再执行。

defer

如果 script 标签设置了该属性，则浏览器会异步的下载该文件并且不会影响到后续 DOM 的渲染；
如果有多个设置了 defer 的 script 标签存在，则会按照顺序执行所有的 script；
defer 脚本会在文档渲染完毕后，DOMContentLoaded 事件调用前执行。

async

async 的设置，会使得 script 脚本异步的加载并在允许的情况下执行 async 的执行，
并不会按着 script 在页面中的顺序来执行，而是谁先加载完谁执行。

• 概括来讲，就是这两个属性都会使 script 标签异步加载，然而执行的时机是不一样的。
• 也就是说 async 是乱序的，而 defer 是顺序执行，这也就决定了async 比较适用于百度分析或者谷歌分析这类不依赖其他脚本的库。

推荐的应用场景

defer

如果你的脚本代码依赖于页面中的 DOM 元素（文档是否解析完毕），或者被其他脚本文件依赖。

例：

• 评论框
• 代码语法高亮
• polyfill.js

async

如果你的脚本并不关心页面中的 DOM 元素（文档是否解析完毕），并且也不会产生其他脚本需要的数据。

例：百度统计

如果不太能确定的话，用 defer 总是会比 async 稳定。。。

参考：浅谈 script 标签中的 async 和 defer

函数里的 this 什么含义，什么情况下，怎么用 ？

• this 是 Javascript 语言的一个关键字。
• 它代表函数运行时，自动生成的一个内部对象，只能在函数内部使用。
• 随着函数使用场合的不同，this 的值会发生变化。
• 但是有一个总的原则，那就是 this 指的是，调用函数的那个对象。

情况一：纯粹的函数调用 

这是函数的最通常用法，属于全局性调用，因此 this 就代表全局对象 window。    　　

function test(){    　　　
  this.x = 1;    　　　　
  alert(this.x);    　　
}    　　
test(); // 1

为了证明 this 就是全局对象，我对代码做一些改变：    　　

var x = 1;    　　
function test(){    　　　　
  alert(this.x);    　　
}    　　
test(); // 1    

运行结果还是 1。

再变一下：    　　

var x = 1;    　　
function test(){    　　　　
  this.x = 0;    　　
}    　　
test();
alert(x); // 0

情况二：作为对象方法的调用   

函数还可以作为某个对象的方法调用，这时 this 就指这个上级对象。   
　　

function test(){    　　　　
  alert(this.x);    　　
}
var x = 2    　　
var o = {};    　　
o.x = 1;    　　
o.m = test;    　　
o.m(); // 1

情况三： 作为构造函数调用   

所谓构造函数，就是通过这个函数生成一个新对象（object）。这时的 this 就指这个新对象。

function Test(){    　　　　
  this.x = 1;    　　
}    　　
var o = new Test();
alert(o.x); // 1    

运行结果为 1。为了表明这时 this 不是全局对象，对代码做一些改变： 
  　　

var x = 2;    　　
function Test(){    　　　　
  this.x = 1;    　　
}    　　
var o = new Test();    　　
alert(x); // 2

运行结果为 2，表明全局变量 x 的值没变。

情况四： apply 调用   

apply() 是函数对象的一个方法，它的作用是改变函数的调用对象，它的第一个参数就表示改变后的调用这个函数的对象。因此，this 指的就是这第一个参数。    　　

var x = 0;    　　
function test(){    　　　　
  alert(this.x);    　　
}    　　
var o = {};    　　
o.x = 1;    　　
o.m = test;    　　
o.m.apply(); // 0    

apply() 的参数为空时，默认调用全局对象。因此，这时的运行结果为 0，证明 this 指的是全局对象。
   
如果把最后一行代码修改为

o.m.apply(o); // 1

运行结果就变成了 1，证明了这时 this 代表的是对象 o。

apply 和 call  什么含义，什么区别 ？什么时候用 ？

call，apply 都属于 Function.prototype 的一个方法，它是 JavaScript 引擎内在实现的，因为属于 Function.prototype，所以每个 Function 对象实例(就是每个方法)都有 call，apply 属性。

既然作为方法的属性，那它们的使用就当然是针对方法的了，这两个方法是容易混淆的，因为它们的作用一样，只是使用方式不同。

语法：

foo.call(this, arg1, arg2, arg3) == foo.apply(this, arguments) == this.foo(arg1, arg2, arg3);

• 相同点：两个方法产生的作用是完全一样的。
• 不同点：方法传递的参数不同。

每个函数对象会有一些方法可以去修改函数执行时里面的 this，比较常见得到就是 call 和 apply，通过 call 和 apply 可以重新定义函数的执行环境，即 this 的指向。

function add(c, d) {
  console.log(this.a + this.b + c + d);
}

var o = { a: 1, b: 3 };
add.call(o, 5, 7);    //1+3+5+7=16
//传参的时候是扁平的把每个参数传进去

add.apply(o, [10, 20]);   //1+3+10+20=34
//传参的时候是把参数作为一个数组传进去

//什么时候使用 call 或者 apply
function bar() {
  console.log(Object.prototype.toString.call(this));
  // 用来调用一些无法直接调用的方法
}

bar.call(7); // "[object Number]"

异步过程的构成要素有哪些？和异步过程是怎样的 ？

总结一下，一个异步过程通常是这样的：

• 主线程发起一个异步请求，相应的工作线程接收请求并告知主线程已收到(异步函数返回)；
• 主线程可以继续执行后面的代码，同时工作线程执行异步任务；
• 工作线程完成工作后，通知主线程；
• 主线程收到通知后，执行一定的动作(调用回调函数)。

1. 异步函数通常具有以下的形式：A(args..., callbackFn)。
2. 它可以叫做异步过程的发起函数，或者叫做异步任务注册函数。
3. args 和 callbackFn 是这个函数的参数。

所以，从主线程的角度看，一个异步过程包括下面两个要素：

• 发起函数(或叫注册函数) A。
• 回调函数 callbackFn。

它们都是在主线程上调用的，其中注册函数用来发起异步过程，回调函数用来处理结果。

举个具体的例子：

setTimeout(fn, 1000);

其中的 setTimeout 就是异步过程的发起函数，fn 是回调函数。

注意：前面说的形式 A(args..., callbackFn) 只是一种抽象的表示，并不代表回调函数一定要作为发起函数的参数。

例如：

var xhr = new XMLHttpRequest();
xhr.onreadystatechange = xxx; // 添加回调函数
xhr.open('GET', url);
xhr.send(); // 发起函数

发起函数和回调函数就是分离的。

说说消息队列和事件循环

• 主线程在执行完当前循环中的所有代码后，就会到消息队列取出这条消息(也就是 message 函数)，并执行它。
• 完成了工作线程对主线程的通知，回调函数也就得到了执行。
• 如果一开始主线程就没有提供回调函数，AJAX 线程在收到 HTTP 响应后，也就没必要通知主线程，从而也没必要往消息队列放消息。

异步过程的回调函数，一定不在当前的这一轮事件循环中执行。

session 与 cookie 的区别

• session 保存在服务器，客户端不知道其中的信息；
• cookie 保存在客户端，服务器能够知道其中的信息。 
• session 中保存的是对象，cookie 中保存的是字符串。   
• session 不能区分路径，同一个用户在访问一个网站期间，所有的 session 在任何一个地方都可以访问到。
• 而 cookie 中如果设置了路径参数，那么同一个网站中不同路径下的 cookie 互相是访问不到的。  

cookies 是干嘛的，服务器和浏览器之间的 cookies 是怎么传的，httponly 的 cookies 和可读写的 cookie 有什么区别，有无长度限制 ?

• cookies 是一些存储在用户电脑上的小文件。
• 它是被设计用来保存一些站点的用户数据，这样能够让服务器为这样的用户定制内容，后者页面代码能够获取到 cookie 值然后发送给服务器。
• 比如 cookie 中存储了所在地理位置，以后每次进入地图就默认定位到改地点即可。

请描述一下 cookies，sessionStorage 和 localStorage 的区别

共同点

• 都是保存在浏览器端，且同源的。

区别

• cookie 数据始终在同源的 http 请求中携带（即使不需要），即 cookie 在浏览器和服务器间来回传递。
• 而 sessionStorage 和 localStorage 不会自动把数据发给服务器，仅在本地保存。
• cookie 数据还有路径（path）的概念，可以限制 cookie 只属于某个路径下。
• 存储大小限制也不同，cookie 数据不能超过 4k，同时因为每次 http 请求都会携带 cookie，所以 cookie 只适合保存很小的数据，如会话标识。
• sessionStorage 和 localStorage 虽然也有存储大小的限制，但比 cookie 大得多，可以达到 5M 或更大。
• 数据有效期不同，sessionStorage：仅在当前浏览器窗口关闭前有效，自然也就不可能持久保持；localStorage：始终有效，窗口或浏览器关闭也一直保存，因此用作持久数据；cookie 只在设置的 cookie 过期时间之前一直有效，即使窗口或浏览器关闭。
• 作用域不同，sessionStorage 在不同的浏览器窗口中不共享，即使是同一个页面；cookie 和 localStorage 在所有同源窗口中都是共享的。

从敲入 URL 到渲染完成的整个过程，包括 DOM 构建的过程，说的约详细越好

• 用户输入 url 地址，浏览器根据域名寻找 IP 地址
• 浏览器向服务器发送 http 请求，如果服务器段返回以 301 之类的重定向，浏览器根据相应头中的 location 再次发送请求
• 服务器端接受请求，处理请求生成 html 代码，返回给浏览器，这时的 html 页面代码可能是经过压缩的
• 浏览器接收服务器响应结果，如果有压缩则首先进行解压处理，紧接着就是页面解析渲染
• 解析渲染该过程主要分为以下步骤：解析 HTML、构建 DOM 树、DOM 树与 CSS 样式进行附着构造呈现树
• 布局
• 绘制

详情：面试题之从敲入 URL 到浏览器渲染完成

是否了解公钥加密和私钥加密。如何确保表单提交里的密码字段不被泄露。

公钥用于对数据进行加密，私钥用于对数据进行解密。

很直观的理解：公钥就是公开的密钥，其公开了大家才能用它来加密数据。私钥是私有的密钥，谁有这个密钥才能够解密密文。

解决方案 1:

form 在提交的过程中，对密码字段是不进行加密而是以明码的形式进行数据传输的。
如果要对数据进行加密，你可以自己写一个脚本对内容进行编码后传输，只是这个安全性也并不高。

解决方案 2:

如果想对数据进行加密，你可以使用 HTTPS 安全传输协议，这个协议是由系统进行密码加密处理的，在数据传输中是绝对不会被拦截获取的，只是 HTTPS 的架设会相对麻烦点。一些大型网站的登录、银行的在线网关等都是走这条路。

验证码是干嘛的，是为了解决什么安全问题。

所谓验证码，就是将一串随机产生的数字或符号，生成一幅图片， 图片里加上一些干扰象素（防止OCR），由用户肉眼识别其中的验证码信息，输入表单提交网站验证，验证成功后才能使用某项功能。

• 验证码一般是防止批量注册的，人眼看起来都费劲，何况是机器。
• 像百度贴吧未登录发贴要输入验证码大概是防止大规模匿名回帖的发生。
• 目前，不少网站为了防止用户利用机器人自动注册、登录、灌水，都采用了验证码技术。

截取字符串 abcdefg 的 efg。

从第四位开始截取

alert('abcdefg'.substring(4));
alert ('abcdefg'.slice(4))

判断一个字符串中出现次数最多的字符，统计这个次数

步骤

• 将字符串转化数组 
• 创建一个对象 
• 遍历数组，判断对象中是否存在数组中的值，如果存在值 +1，不存在赋值为 1
• 定义两个变量存储字符值，字符出现的字数

var str = 'abaasdffggghhjjkkgfddsssss3444343';
// 1.将字符串转换成数组
var newArr = str.split("");
// 2.创建一个对象
var json = {};
// 3. 所有字母出现的次数，判断对象中是否存在数组中的值，如果存在值 +1，不存在赋值为 1
for(var i = 0; i < newArr.length; i++){
      // 类似：json : { ‘a’: 3, ’b’: 1 }
      if(json[newArr[i]]){
         json[newArr[i]] +=1;
      } else {
           json[newArr[i]] = 1;
      }
}
// 4 定义两个变量存储字符值，字符出现的字数
var num = 0 ; //次数
var element = ""; //最多的项
for(var k in json){
   if(json[k] > num){
     num = json[k];
     element = k ;
   }
}
console.log("出现次数："+num +"最多的字符："+ element);

document.write 和 innerHTML 的区别

• document.write 是直接写入到页面的内容流，如果在写之前没有调用 document.open, 浏览器会自动调用 open。每次写完关闭之后重新调用该函数，会导致页面被重写。
• innerHTML 则是 DOM 页面元素的一个属性，代表该元素的 html 内容。你可以精确到某一个具体的元素来进行更改。如果想修改 document 的内容，则需要修改 document.documentElement.innerElement。
• innerHTML 将内容写入某个 DOM 节点，不会导致页面全部重绘。
• innerHTML 很多情况下都优于 document.write，其原因在于其允许更精确的控制要刷新页面的那一个部分。
• document.write 是重写整个 document, 写入内容是字符串的 html；innerHTML 是 HTMLElement 的属性，是一个元素的内部 html 内容 

JS 识别不同浏览器信息

function myBrowser() {
  var userAgent = navigator.userAgent; //取得浏览器的userAgent字符串  
  var isOpera = userAgent.indexOf("Opera") > -1;
  if (isOpera) {
    return "Opera"
  }; //判断是否Opera浏览器  
  if (userAgent.indexOf("Firefox") > -1) {
    return "Firefox";
  }  //判断是否Firefox浏览器  
  if (userAgent.indexOf("Chrome") > -1) {
    return "Chrome";
  }   //判断是否Google浏览器  
  if (userAgent.indexOf("Safari") > -1) {
    return "Safari";
  } //判断是否Safari浏览器  
  if (userAgent.indexOf("compatible") > -1 && userAgent.indexOf("MSIE") > -1 && !isOpera) {
    return "IE";
  }; //判断是否IE浏览器  
} 

JavaScript 常见的内置对象

有 Object、Math、String、Array、Number、Function、Boolean、JSON 等，其中 Object 是所有对象的基类，采用了原型继承方式。

编写一个方法，求一个字符串的字节长度

假设：一个英文字符占用一个字节，一个中文字符占用两个字节

function getBytes(str){
    var len = str.length;
    var bytes = len;
    for(var i = 0; i < len; i++){
        if (str.charCodeAt(i) > 255)  bytes++;
    }
    return bytes;
}
alert(getBytes("你好,as"));

JS 组成

• 核心（ECMAScript） 描述了该语言的语法和基本对象
• 文档对象模型(DOM) 描述了处理网页内容的方法和接口
• 浏览器对象模型(BOM) 描述了与浏览器进行交互的方法和接口

new 操作符具体干了什么呢 ?

• 创建一个空对象，并且 this 变量引用该对象，同时还继承了该函数的原型。
• 属性和方法被加入到 this 引用的对象中。
• 新创建的对象由 this 所引用，并且最后隐式的返回 this 。

JSON 的了解？

• JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。
• 它是基于 JavaScript 的一个子集。
• 数据格式简单，易于读写，占用带宽小。
• 格式：采用键值对。例如：{ “age‟: ‟12‟, ”name‟: ‟back‟ }

你有哪些性能优化的方法 ？

web 前端是应用服务器处理之前的部分，前端主要包括：HTML、CSS、javascript、image 等各种资源，针对不同的资源有不同的优化方式。

内容优化

• 减少 HTTP 请求数。这条策略是最重要最有效的，因为一个完整的请求要经过 DNS 寻址，与服务器建立连接，发送数据，等待服务器响应，接收数据这样一个消耗时间成本和资源成本的复杂的过程。
  常见方法：合并多个 CSS 文件和 js 文件，利用 CSS Sprites 整合图像，Inline Images (使用 data：URL scheme 在实际的页面嵌入图像数据 )，合理设置 HTTP 缓存等。
• 减少 DNS 查找
• 避免重定向
• 使用 Ajax 缓存
• 延迟加载组件，预加载组件
• 减少 DOM 元素数量。页面中存在大量 DOM 元素，会导致 javascript 遍历 DOM 的效率变慢。
• 最小化 iframe 的数量。iframes 提供了一个简单的方式把一个网站的内容嵌入到另一个网站中。但其创建速度比其他包括 JavaScript 和 CSS 的 DOM 元素的创建慢了 1-2 个数量级。
• 避免 404。HTTP 请求时间消耗是很大的，因此使用 HTTP 请求来获得一个没有用处的响应（例如 404 没有找到页面）是完全没有必要的，它只会降低用户体验而不会有一点好处。

服务器优化

• 使用内容分发网络（CDN）。把网站内容分散到多个、处于不同地域位置的服务器上可以加快下载速度。
• GZIP 压缩
• 设置 ETag：ETags（Entity tags，实体标签）是 web 服务器和浏览器用于判断浏览器缓存中的内容和服务器中的原始内容是否匹配的一种机制。
• 提前刷新缓冲区
• 对 Ajax 请求使用 GET 方法
• 避免空的图像 src

Cookie 优化

• 减小 Cookie 大小
• 针对 Web 组件使用域名无关的 Cookie

CSS 优化

• 将 CSS 代码放在 HTML 页面的顶部
• 避免使用 CSS 表达式
• 使用 < link> 来代替 @import
• 避免使用 Filters

javascript 优化

• 将 JavaScript 脚本放在页面的底部。
• 将 JavaScript 和 CSS 作为外部文件来引用。
  在实际应用中使用外部文件可以提高页面速度，因为 JavaScript 和 CSS 文件都能在浏览器中产生缓存。
• 缩小 JavaScript 和 CSS
• 删除重复的脚本
• 最小化 DOM 的访问。使用 JavaScript 访问 DOM 元素比较慢。
• 开发智能的事件处理程序
• javascript 代码注意：谨慎使用 with，避免使用 eval Function 函数，减少作用域链查找。

图像优化

• 优化图片大小
• 通过 CSS Sprites 优化图片
• 不要在 HTML 中使用缩放图片
• favicon.ico 要小而且可缓存

前端性能优化 24 条建议（2020）

JS 格式化数字（每三位加逗号）

从后往前取。

function toThousands(num) {  
    var num = (num || 0).toString(), result = '';  
    while (num.length > 3) {  
        result = ',' + num.slice(-3) + result;  
        num = num.slice(0, num.length - 3);  
    }  
    if (num) { result = num + result; }  
    return result;  
}  

合并数组

如果你需要合并两个数组的话，可以使用 Array.concat()

var array1 = [1, 2, 3];
var array2 = [4, 5, 6];
console.log(array1.concat(array2)); // [1,2,3,4,5,6];

然而，这个函数并不适用于合并大的数组，因为它需要创建一个新的数组，而这会消耗很多内存。

这时，你可以使用 Array.push.apply(arr1, arr2) 来代替创建新的数组，它可以把第二个数组合并到第一个中，从而较少内存消耗。

var array1 = [1, 2, 3];
var array2 = [4, 5, 6];
console.log(array1.push.apply(array1, array2)); // [1, 2, 3, 4, 5, 6]

把节点列表 (NodeList) 转换为数组

如果你运行 document.querySelectorAll("p") 方法，它可能会返回一个 DOM 元素的数组 — 节点列表对象。
但这个对象并不具有数组的全部方法，如 sort()，reduce()， map()，filter()。
为了使用数组的那些方法，你需要把它转换为数组。

只需使用 [].slice.call(elements) 即可实现：

var elements = document.querySelectorAll("p"); // NodeList
var arrayElements = [].slice.call(elements); // 现在 NodeList 是一个数组

var arrayElements = Array.from(elements); // 这是另一种转换 NodeList 到 Array  的方法

打乱数组元素的顺序

不适用 Lodash 等这些库打乱数组元素顺序，你可以使用这个技巧：

var list = [1, 2, 3];
console.log(list.sort(function() { Math.random() - 0.5 })); // [2, 1, 3]

js 的 ready 和 onload 事件的区别

• onload 是等 HTML 的所有资源都加载完成后再执行 onload 里面的内容，所有资源包括 DOM 结构、图片、视频 等资源;
• ready 是当 DOM 结构加载完成后就可以执行了，相当于 jQuery 中的 $(function(){ js 代码 });
• 另外，onload 只能有一个，ready 可以有多个。

js 的两种回收机制

标记清除（mark and sweep）

从语义上理解就比较好理解了，大概就是当变量进入到某个环境中的时候就把这个变量标记一下，比如标记为“进入环境”，当离开的时候就把这个变量的标记给清除掉，比如是“离开环境”。而在这后面还有标记的变量将被视为准备删除的变量。

• 垃圾收集器在运行的时候会给存储在内存中的所有变量都加上标记（可以使用任何标记方式）。
• 然后，它会去掉环境中的变量以及被环境中的变量引用的变量的标记。
• 而在此之后再被加上的标记的变量将被视为准备删除的变量，原因是环境中的变量已经无法访问到这些变量了。
• 最后，垃圾收集器完成内存清除工作。销毁那些带标记的值并回收它们所占用的内存空间。

这是 javascript 最常见的垃圾回收方式。至于上面有说道的标记，到底该如何标记 ？
好像是有很多方法，比如特殊位翻转，维护一个列表什么的。

引用计数（reference counting）

• 引用计数的含义是跟踪记录每个值被引用的次数，当声明一个变量并将一个引用类型的值赋给该变量时，这个时候的引用类型的值就会是引用次数 +1 了。如果同一个值又被赋给另外一个变量，则该值的引用次数又 +1。
• 相反如果包含这个值的引用的变量又取得另外一个值，即被重新赋了值，那么这个值的引用就 -1 。当这个值的引用次数编程 0 时，表示没有用到这个值，这个值也无法访问，因此环境就会收回这个值所占用的内存空间回收。
• 这样，当垃圾收集器下次再运行时，它就会释放引用次数为 0 的值所占用的内存。

三张图搞懂 JavaScript 的原型对象与原型链

对于新人来说，JavaScript 的原型是一个很让人头疼的事情，一来 prototype 容易与 proto 混淆，

一、prototype 和 proto 的区别

var a = {};
console.log(a.prototype);  //undefined
console.log(a.__proto__);  //Object {}

var b = function(){}
console.log(b.prototype);  //b {}
console.log(b.__proto__);  //function() {}

结果：

/*1、字面量方式*/
var a = {};
console.log("a.__proto__ ：", a.__proto__);  // Object {}
console.log("a.__proto__ === a.constructor.prototype：", a.__proto__ === a.constructor.prototype); // true

/*2、构造器方式*/
var A = function(){};
var a2 = new A();
console.log("a2.__proto__：", a2.__proto__); // A {}
console.log("a2.__proto__ === a2.constructor.prototype：", a2.__proto__ === a2.constructor.prototype); // true

/*3、Object.create()方式*/
var a4 = { a: 1 }
var a3 = Object.create(a4);
console.log("a3.__proto__：", a3.__proto__); // Object {a: 1}
console.log("a3.__proto__ === a3.constructor.prototype：", a3.__proto__ === a3.constructor.prototype); // false（此处即为图1中的例外情况）

结果：

var A = function(){};
var a = new A();
console.log(a.__proto__); // A {}（即构造器 function A 的原型对象）
console.log(a.__proto__.__proto__); // Object {}（即构造器 function Object 的原型对象）
console.log(a.__proto__.__proto__.__proto__); // null

结果：

闭包的理解 ？

一、变量的作用域

要理解闭包，首先必须理解 Javascript 特殊的变量作用域。
变量的作用域无非就是两种：全局变量和局部变量。

Javascript语言的特殊之处，就在于函数内部可以直接读取全局变量。

var n = 999;
function f1(){
  alert(n);
}
f1(); // 999

另一方面，在函数外部自然无法读取函数内的局部变量。

function f1(){　　　　
  var n = 999;
}
alert(n); // error

这里有一个地方需要注意，函数内部声明变量的时候，一定要使用 var 命令。
如果不用的话，你实际上声明了一个全局变量！

function f1(){
  n = 999;
}
f1();
alert(n); // 999

二、如何从外部读取局部变量 ？

function f1() {
  var n = 999;
  function f2() {
    alert(n);
  }
  return f2;
}
var result = f1();
result(); // 999

既然 f2 可以读取 f1 中的局部变量，那么只要把 f2 作为返回值，我们不就可以在 f1 外部读取它的内部变量了吗！

三、闭包的概念

上一节代码中的 f2 函数，就是闭包。
我的理解是，闭包就是能够读取其他函数内部变量的函数。

由于在 Javascript 语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成 定义在一个函数内部的函数。
所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。

四、闭包的用途

闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。

怎么来理解呢 ？请看下面的代码。

function f1() {
  var n = 999;
  nAdd = function () { n += 1 }
  function f2() {
    alert(n);
  }
  return f2;
}
var result = f1();
result(); // 999
nAdd();
result(); // 1000

在这段代码中，result 实际上就是闭包 f2 函数。它一共运行了两次，第一次的值是 999，第二次的值是 1000。这证明了，函数 f1 中的局部变量 n 一直保存在内存中，并没有在 f1 调用后被自动清除。

为什么会这样呢 ？

原因就在于 f1 是 f2 的父函数，而 f2 被赋给了一个全局变量，这导致 f2 始终在内存中，而 f2 的存在依赖于 f1，因此 f1 也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection）回收。

这段代码中另一个值得注意的地方，就是

• "nAdd=function(){ n+=1 }" 这一行，首先在 nAdd 前面没有使用 var 关键字，因此 nAdd 是一个全局变量，而不是局部变量。
• 其次，nAdd 的值是一个匿名函数（anonymous function），而这个匿名函数本身也是一个闭包，所以 nAdd 相当于是一个 setter，可以在函数外部对函数内部的局部变量进行操作。

五、使用闭包的注意点

• 由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在 IE 中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。
• 闭包会在父函数外部，改变父函数内部变量的值。所以，如果你把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。

闭包面试经典问题

问题：想每次点击对应目标时弹出对应的数字下标 0~4 ，但实际是无论点击哪个目标都会弹出数字 5。

function onMyLoad() {
  var arr = document.getElementsByTagName("p");
  for (var i = 0; i < arr.length; i++) {
    arr[i].onclick = function () {
      alert(i);
    }
  }
}

问题所在：arr 中的每一项的 onclick 均为一个函数实例(Function 对象)，这个函数实例也产生了一个闭包域，这个闭包域引用了外部闭包域的变量，其 function scope 的 closure 对象有个名为 i 的引用，外部闭包域的私有变量内容发生变化，内部闭包域得到的值自然会发生改变。

解决办法一

解决思路：增加若干个对应的闭包域空间(这里采用的是匿名函数)，专门用来存储原先需要引用的内容(下标)，不过只限于基本类型(基本类型值传递，对象类型引用传递)。

//声明一个匿名函数，若传进来的是基本类型则为值传递，故不会对实参产生影响,
//该函数对象有一个本地私有变量 arg(形参) ，该函数的 function scope 的 closure 对象属性有两个引用，一个是 arr，一个是 i
//尽管引用 i 的值随外部改变 ，但本地私有变量(形参) arg 不会受影响，其值在一开始被调用的时候就决定了
for (var i = 0; i < arr.length; i++) {
  (function (arg) {
    arr[i].onclick = function () {
      // onclick 函数实例的 function scope 的 closure 对象属性有一个引用 arg,
      alert(arg);
      //只要 外部空间的 arg 不变，这里的引用值当然不会改变
    }
  })(i); //立刻执行该匿名函数，传递下标 i (实参)
}

解决办法二

解决思路：将事件绑定在新增的匿名函数返回的函数上，此时绑定的函数中的 function scope 中的 closure 对象的 引用 arg 是指向将其返回的匿名函数的私有变量 arg

for (var i = 0; i < arr.length; i++) {
  arr[i].onclick = (function (arg) {
    return function () {
      alert(arg);
    }
  })(i);
}

解决办法三

使用 ES6 新语法 let 关键字

for (var i = 0; i < arr.length; i++) {
  let j = i; // 创建一个块级变量
  arr[i].onclick = function () {
    alert(j);
  }
}

js闭包的9个使用场景

JavaScript 判断一个变量是对象还是数组 ？

typeof 都返回 object

在 JavaScript 中所有数据类型严格意义上都是对象，但实际使用中我们还是有类型之分，如果要判断一个变量是数组还是对象使用 typeof 搞不定，因为它全都返回 object。

第一，使用 typeof 加 length 属性

数组有 length 属性，object 没有，而 typeof 数组与对象都返回 object，所以我们可以这么判断

var getDataType = function(o){
    if(typeof o == 'object'){
        if( typeof o.length == 'number' ){
            return 'Array';
        } else {
            return 'Object';   
        }
    } else {
        return 'param is no object type';
    }
};

第二，使用 instanceof

利用 instanceof 判断数据类型是对象还是数组时应该优先判断 array，最后判断 object。

var getDataType = function(o){
    if(o instanceof Array){
        return 'Array'
    } else if ( o instanceof Object ){
        return 'Object';
    } else {
        return 'param is no object type';
    }
};

ES5 的继承和 ES6 的继承有什么区别 ？

ES5 的继承时通过 prototype 或构造函数机制来实现。

• ES5 的继承实质上是先创建子类的实例对象，然后再将父类的方法添加到 this 上（Parent.apply(this)）。
• ES6 的继承机制完全不同，实质上是先创建父类的实例对象 this（所以必须先调用父类的 super()方法），然后再用子类的构造函数修改 this。

具体的：ES6 通过 class 关键字定义类，里面有构造方法，类之间通过 extends 关键字实现继承。子类必须在 constructor 方法中调用 super 方法，否则新建实例报错。因为子类没有自己的 this 对象，而是继承了父类的 this 对象，然后对其进行加工。如果不调用 super 方法，子类得不到 this 对象。

ps：super 关键字指代父类的实例，即父类的 this 对象。在子类构造函数中，调用 super 后，才可使用 this 关键字，否则报错。

JS 中数据类型的判断 typeof，instanceof，constructor，Object.prototype.toString.call() 的区别

参考文章：

1. JS 中数据类型的判断
2. JS类型判断---typeof, constructor, instanceof, toString

翻转一个字符串

先将字符串转成一个数组，然后用数组的 reverse() + join() 方法。

let a = "hello word";
let b = [...str].reverse().join(""); // drow olleh

说说堆和栈的区别 ？
　

一、堆栈空间分配区别
　　

• 栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；　　
• 堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由 OS 回收，分配方式倒是类似于链表。　　

二、堆栈缓存方式区别

• 栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放；　　
• 堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。　　

三、堆栈数据结构区别

• 堆（数据结构）：堆可以被看成是一棵树，如：堆排序；　　
• 栈（数据结构）：一种先进后出的数据结构。

js 经典面试知识文章

• js 异步执行顺序
• JS 是单线程，你了解其运行机制吗 ？
• 7 分钟理解 JS 的节流、防抖及使用场景
• JavaScript 常见的六种继承方式
• JS 继承的 6 种实现方式
• 九种跨域方式实现原理（完整版）
• 常见六大Web安全攻防解析
• 一文读懂 HTTP/2 及 HTTP/3 特性
• 深入理解 HTTPS 工作原理
• JavaScript 中的垃圾回收和内存泄漏
• 你不知道的浏览器页面渲染机制
• JavaScript设计模式
• 深入 javascript——构造函数和原型对象
• 高级函数技巧-函数柯里化
• JavaScript之bind及bind的模拟实现
• Http Cookie 机制及 Cookie 的实现原理
• 一个dom,点击事件触发两个事件是同步还是异步
• 16种JavaScript设计模式（中）

5. ES6 +

ES6 函数默认参数和 es5 的实现有什么区别 ？es6 中又有什么需要注意的 ？

ES6函数默认参数

ES6 声明变量的六种方法

• ES5 只有两种声明变量的方法：var 和 function 。
• ES6 除了添加 let 和 const 命令。
• 还有两种声明变量的方法：import 命令和 class 命令。

Promise 的队列与 setTimeout 的队列有何关联 ？

setTimeout(function(){ console.log(4) }, 0);
new Promise(function(resolve){
    console.log(1)
    for( var i = 0 ; i < 10000 ; i++ ){
        i == 9999 && resolve()
    }
    console.log(2)
}).then(function(){
    console.log(5)
});
console.log(3);

为什么结果是：1, 2, 3, 5, 4；而不是：1, 2, 3, 4, 5 ？

js 里面有宏任务（macrotask）和微任务（microtask）。因为 setTimeout 是属于 macrotask 的，而整个 script 也是属于一个 macrotask，promise.then 回调是 microtask，执行过程大概如下：

• 由于整个 script 也属于一个 macrotask，由于会先执行 macrotask 中的第一个任务，再加上 promise 构造函数因为是同步的，所以会先打印出 1 和 2；
• 然后继续同步执行末尾的 console.log(3) 打印出 3；
• 此时 setTimeout 被推进到 macrotask 队列中， promise.then 回调被推进到 microtask 队列中；
• 由于在第一步中已经执行完了第一个 macrotask ，所以接下来会顺序执行所有的 microtask，也就是 promise.then 的回调函数，从而打印出 5；
• microtask 队列中的任务已经执行完毕，继续执行剩下的 macrotask 队列中的任务，也就是 setTimeout，所以打印出 4。

防抖与节流

节流

throttle 的中心思想在于：在某段时间内，不管你触发了多少次回调，我都只认第一次，并在计时结束时给予响应。

// fn 是我们需要包装的事件回调, delay 是时间间隔的阈值
function throttle(fn, delay) {
  // last 为上一次触发回调的时间
  let last = 0
  
  // 将 throttle 处理结果当作函数返回
  return function () {
      // 保留调用时的 this 上下文
      let context = this
      // 保留调用时传入的参数
      let args = arguments
      // 记录本次触发回调的时间
      let now = +new Date()
      
      // 判断上次触发的时间和本次触发的时间差是否小于时间间隔的阈值
      if (now - last >= delay) {
          // 如果时间间隔大于我们设定的时间间隔阈值，则执行回调
          last = now;
          fn.apply(context, args);
      }
    }
}

// 用 throttle 来包装 scroll 的回调
const better_scroll = throttle(() => console.log('触发了滚动事件'), 1000)

document.addEventListener('scroll', better_scroll)

防抖

防抖的中心思想在于：我会等你到底。在某段时间内，不管你触发了多少次回调，我都只认最后一次。

// fn  是我们需要包装的事件回调, delay 是每次推迟执行的等待时间
function debounce(fn, delay) {
  // 定时器
  let timer = null
  
  // 将 debounce 处理结果当作函数返回
  return function () {
    // 保留调用时的 this 上下文
    let context = this
    // 保留调用时传入的参数
    let args = arguments

    // 每次事件被触发时，都去清除之前的旧定时器
    if(timer) {
        clearTimeout(timer)
    }
    // 设立新定时器
    timer = setTimeout(function () {
      fn.apply(context, args)
    }, delay)
  }
}

// 用 debounce 来包装 scroll 的回调
const better_scroll = debounce(() => console.log('触发了滚动事件'), 1000)

document.addEventListener('scroll', better_scroll)

用 Throttle 来优化 Debounce

思想：在 delay 时间内，我可以为你重新生成定时器；但只要 delay 的时间到了，我必须要给用户一个响应。

// fn 是我们需要包装的事件回调, delay 是时间间隔的阈值
function throttle(fn, delay) {
  // last 为上一次触发回调的时间, timer 是定时器
  let last = 0, timer = null

  // 将 throttle 处理结果当作函数返回
  return function () { 
    // 保留调用时的 this 上下文
    let context = this
    // 保留调用时传入的参数
    let args = arguments
    // 记录本次触发回调的时间
    let now = +new Date()
    
    // 判断上次触发的时间和本次触发的时间差是否小于时间间隔的阈值
    if (now - last < delay) {
        // 如果时间间隔小于我们设定的时间间隔阈值，则为本次触发操作设立一个新的定时器
        clearTimeout(timer)
        timer = setTimeout(function () {
          last = now
          fn.apply(context, args)
        }, delay)
    } else {
        // 如果时间间隔超出了我们设定的时间间隔阈值，那就不等了，无论如何要反馈给用户一次响应
        last = now
        fn.apply(context, args)
    }
  }
}

// 用新的 throttle 包装 scroll 的回调
const better_scroll = throttle(() => console.log('触发了滚动事件'), 1000)

document.addEventListener('scroll', better_scroll)

以上答案来自于：事件的节流（throttle）与防抖（debounce）

手写实现一个简单版本的 promise

// 三个常量用于表示状态
const PENDING = 'pending'
const RESOLVED = 'resolved'
const REJECTED = 'rejected'

function MyPromise(fn) {
    const that = this
    this.state = PENDING

    // value 变量用于保存 resolve 或者 reject 中传入的值
    this.value = null

    // 用于保存 then 中的回调，因为当执行完 Promise 时状态可能还是等待中，这时候应该把 then 中的回调保存起来用于状态改变时使用
    that.resolvedCallbacks = []
    that.rejectedCallbacks = []


    function resolve(value) {
         // 首先两个函数都得判断当前状态是否为等待中
        if(that.state === PENDING) {
            that.state = RESOLVED
            that.value = value

            // 遍历回调数组并执行
            that.resolvedCallbacks.map(cb=>cb(that.value))
        }
    }
    function reject(value) {
        if(that.state === PENDING) {
            that.state = REJECTED
            that.value = value
            that.rejectedCallbacks.map(cb=>cb(that.value))
        }
    }

    // 完成以上两个函数以后，我们就该实现如何执行 Promise 中传入的函数了
    try {
        fn(resolve,reject)
    }cach(e){
        reject(e)
    }
}

// 最后我们来实现较为复杂的 then 函数
MyPromise.prototype.then = function(onFulfilled,onRejected){
  const that = this

  // 判断两个参数是否为函数类型，因为这两个参数是可选参数
  onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : v => v;
  onRejected = typeof onRejected === 'function' ? onRejected : e => throw e;

  // 当状态不是等待态时，就去执行相对应的函数。如果状态是等待态的话，就往回调函数中 push 函数
  if(this.state === PENDING) {
      this.resolvedCallbacks.push(onFulfilled)
      this.rejectedCallbacks.push(onRejected)
  }
  if(this.state === RESOLVED) {
      onFulfilled(that.value)
  }
  if(this.state === REJECTED) {
      onRejected(that.value)
  }
}

ES6+ 面试知识文章

• 那些必会用到的 ES6 精粹
• promise、Generator 函数、async 函数的区别与理解
• Typescript 中的 interface 和 type 到底有什么区别
• 进大厂必会 20 道 JS 原理题
• AST 抽象语法树——最基础的 javascript 重点知识，99% 的人根本不了解

6. webpack

说下 webpack 的几大特色 ?

• code splitting（可以自动完成）(根据代码的分割并对文件进行分块)
• loader 可以处理各种类型的静态文件，并且支持串联操作
• webpack 是以 commonJS 的形式来书写脚本滴，但对 AMD/CMD 的支持也很全面，方便旧项目进行代码迁移
• webpack 具有 requireJs 和 browserify 的功能，但仍有很多自己的新特性：
• 对 CommonJS 、 AMD 、ES6 的语法做了兼容
• 对 js、css、图片等资源文件都支持打包
• 串联式模块加载器以及插件机制，让其具有更好的灵活性和扩展性，例如：提供对 CoffeeScript、ES6 的支持
• 有独立的配置文件 webpack.config.js
• 可以将代码切割成不同的 chunk，实现按需加载，降低了初始化时间
• 支持 SourceUrls 和 SourceMaps，易于调试
• 具有强大的 Plugin 接口，大多是内部插件，使用起来比较灵活
• webpack 使用异步 IO 并具有多级缓存。这使得 webpack 很快且在增量编译上更加快

说说对 webpack 的理解，优点、原理、打包的过程

优点

• 依赖管理：方便引用第三方模块、让模块更容易复用、避免全局注入导致的冲突、避免重复加载或加载不需要的模块。
• 合并代码：把各个分散的模块集中打包成大文件，减少 HTTP 的请求链接数，配合 UglifyJS 可以减少、优化代码的体积。
• 各路插件：babel 把 ES6+ 转译成 ES5 ，eslint 可以检查编译期的错误……

原理

一切皆为模块，由于 webpack 并不支持除 .js 以外的文件，从而需要使用 loader 转换成 webpack 支持的模块，plugin 用于扩展 webpack 的功能，在 webpack 构建生命周期的过程在合适的时机做了合适的事情。

webpack 从构建到输出文件结果的过程

• 解析配置参数，合并从 shell 传入和 webpack.config.js 文件的配置信息，输出最终的配置信息
• 注册配置中的插件，好让插件监听 webpack 构建生命周期中的事件节点，做出对应的反应
• 解析配置文件中 entry 入口文件，并找出每个文件依赖的文件，递归下去
• 在递归每个文件的过程中，根据文件类型和配置文件中 loader 找出相对应的 loader 对文件进行转换
• 递归结束之后得到每个文件最终的结果，根据 entry 配置生成代码 chunk
• 输出所有 chunk 到文件系统

• webpack 系列--浅析 webpack 的原理
• 一看就懂之 webpack 原理解析与实现一个简单的 webpack

7. Vue

对 MVC、MVP 、MVVM 的理解

MVC 模式的意思是，软件可以分成三个部分。

• 视图（View）：用户界面。
• 控制器（Controller）：业务逻辑。
• 模型（Model）：数据保存。

各部分之间的通信方式如下。

• View 传送指令到 Controller
• Controller 完成业务逻辑后，要求 Model 改变状态
• Model 将新的数据发送到 View，用户得到反馈
• 所有通信都是单向的（逆时针）。

MVP 模式将 Controller 改名为 Presenter，同时改变了通信方向。

• 各部分之间的通信，都是双向的（顺时针）。
• View 与 Model 不发生联系，都通过 Presenter 传递。
• View 非常薄，不部署任何业务逻辑，称为 "被动视图"（Passive View），即没有任何主动性，而 Presenter非常厚，所有逻辑都部署在那里。

MVVM 模式将 Presenter 改名为 ViewModel，基本上与 MVP 模式完全一致。

唯一的区别是，它采用双向绑定（data-binding）：View 的变动，自动反映在 ViewModel，反之亦然。Angular 和 Ember 都采用这种模式。

如何理解 Vue 是异步执行 DOM 更新的 ？

• Vue 是异步执行 DOM 更新。
• 只要观察到数据变化，Vue 将开启一个队列，并缓冲在同一事件循环中发生的所有数据改变。
• 如果同一个 watcher 被多次触发，只会被推入到队列中一次。这种在缓冲时去除重复数据对于避免不必要的计算和 DOM 操作上非常重要。
• 然后，在下一个的事件循环 tick 中，Vue 刷新队列并执行实际 (已去重的) 工作。Vue 在内部尝试对异步队列使用原生的 Promise.then 和 MessageChannel，如果执行环境不支持，会采用 setTimeout(fn, 0) 代替。

例如，当你设置 vm.someData = 'new value' ，该组件不会立即重新渲染。

• 当刷新队列时，组件会在事件循环队列清空时的下一个 tick 更新。
• 多数情况我们不需要关心这个过程，但是如果你想在 DOM 状态更新后做点什么，这就可能会有些棘手。
• 虽然 Vue.js 通常鼓励开发人员沿着 “数据驱动” 的方式思考，避免直接接触 DOM，但是有时我们确实要这么做。为了在数据变化之后等待 Vue 完成更新 DOM ，可以在数据变化之后立即使用 Vue.nextTick(callback) 。这样回调函数在 DOM 更新完成后就会调用。

深入响应式原理

如何追踪变化

• 当你把一个普通的 JavaScript 对象传给 Vue 实例的 data 选项，Vue 将遍历此对象所有的属性，并使用 Object.defineProperty 把这些属性全部转 getter/setter。
• Object.defineProperty 是 ES5 中一个无法 shim 的特性，这也就是为什么 Vue 不支持 IE8 以及更低版本浏览器的原因。
• 这些 getter/setter 对用户来说是不可见的，但是在内部它们让 Vue 追踪依赖，在属性被访问和修改时通知变化。这里需要注意的问题是浏览器控制台在打印数据对象时 getter/setter 的格式化并不同，所以你可能需要安装 vue-devtools 来获取更加友好的检查接口。
• 每个组件实例都有相应的 watcher 实例对象，它会在组件渲染的过程中把属性记录为依赖，之后当依赖项的 setter 被调用时，会通知 watcher 重新计算，从而致使它关联的组件得以更新。
• 观察者订阅了可观察对象，当可观察对象发布事件，则就直接调度观察者的行为，所以这里观察者和可观察对象其实就产生了一个依赖的关系。

说下对 Virtual DOM 算法的理解 ？

包括几个步骤：

• 1、用 JavaScript 对象结构表示 DOM 树的结构，然后用这个树构建一个真正的 DOM 树，插到文档当中；
• 2、当状态变更的时候，重新构造一棵新的对象树，然后用新的树和旧的树进行比较，记录两棵树差异；
• 3、把 2 所记录的差异应用到步骤 1 所构建的真正的 DOM 树上，视图就更新了。

Virtual DOM 本质上就是在 JS 和 DOM 之间做了一个缓存。可以类比 CPU 和硬盘，既然硬盘这么慢，我们就在它们之间加个缓存：既然 DOM 这么慢，我们就在它们 JS 和 DOM 之间加个缓存。CPU（JS）只操作内存（Virtual DOM），最后的时候再把变更写入硬盘（DOM）。

比较两棵虚拟 DOM 树的差异

比较两棵 DOM 树的差异是 Virtual DOM 算法最核心的部分，这也是所谓的 Virtual DOM 的 diff 算法。
两个树的完全的 diff 算法是一个时间复杂度为 O(n^3) 的问题。但是在前端当中，你很少会跨越层级地移动 DOM 元素。

所以 Virtual DOM 只会对同一个层级的元素进行对比：

上面的 div 只会和同一层级的 div 对比，第二层级的只会跟第二层级对比。这样算法复杂度就可以达到 O(n)。

深度优先遍历，记录差异

在实际的代码中，会对新旧两棵树进行一个深度优先的遍历，这样每个节点都会有一个唯一的标记：

在深度优先遍历的时候，每遍历到一个节点就把该节点和新的的树进行对比。如果有差异的话就记录到一个对象里面。

Virtual DOM 算法主要是实现上面步骤的三个函数：element，diff，patch。然后就可以实际的进行使用：

// 1. 构建虚拟 DOM
var tree = el('div', {'id': 'container'}, [
    el('h1', {style: 'color: blue'}, ['simple virtal dom']),
    el('p', ['Hello, virtual-dom']),
    el('ul', [el('li')])
])
// 2. 通过虚拟 DOM 构建真正的 DOM
var root = tree.render()
document.body.appendChild(root)
// 3. 生成新的虚拟 DOM
var newTree = el('div', {'id': 'container'}, [
    el('h1', {style: 'color: red'}, ['simple virtal dom']),
    el('p', ['Hello, virtual-dom']),
    el('ul', [el('li'), el('li')])
])
// 4. 比较两棵虚拟 DOM 树的不同
var patches = diff(tree, newTree)
// 5. 在真正的 DOM 元素上应用变更
patch(root, patches)

当然这是非常粗糙的实践，实际中还需要处理事件监听等；生成虚拟 DOM 的时候也可以加入 JSX 语法。这些事情都做了的话，就可以构造一个简单的 ReactJS 了。

• 深度剖析：如何实现一个 Virtual DOM 算法
• virtual-dom(Vue实现)简析

非父子组件如何通信 ？

Vue 官网介绍了非父子组件通信方法：

在 bus.js 里面 写入下面信息

import Vue from 'vue'
export default new Vue;

在需要通信的组件都引入 Bus.js    

<template>
  <div id="emit">
    <button @click="bus">按钮</button>
  </div> 
</template > 
import Bus from './bus.js'
export default {
  data() {
    return {
      message: ''
    }
  },
  methods: {
    bus() {
      Bus.$emit('msg', '我要传给兄弟组件们，你收到没有')
    }
  }
}

在钩子函数中监听 msg 事件：

<template>
    <div id="on">
      <p>{{message}}</p>
    </div>
</template>
import Bus from './bus.js'
export default {
    data() {
      return {
        message:  ''
      }
    },
    mounted() {　　　
       let self = this
       Bus.$on('msg', (e) => {
         self.message = e
         console.log(`传来的数据是：${e}`)
       })
    }
  }

最后 p 会显示来自 $emit 传来的信息。

什么情况下我应该使用 Vuex ？

• 虽然 Vuex 可以帮助我们管理共享状态，但也附带了更多的概念和框架。这需要对短期和长期效益进行权衡。
• 如果您不打算开发大型单页应用，使用 Vuex 可能是繁琐冗余的。确实是如此，如果您的应用够简单，您最好不要使用 Vuex。一个简单的 global event bus 就足够您所需了。
• 但是，如果您需要构建一个中大型单页应用，您很可能会考虑如何更好地在组件外部管理状态，Vuex 将会成为自然而然的选择。

在 Vue 2 的实现中，在组件初始化阶段把数据变成响应式时，遇到子属性仍然是对象的情况，会递归执行 Object.defineProperty 定义子对象的响应式；而在 Vue 3 的实现中，只有在对象属性被访问的时候才会判断子属性的类型来决定要不要递归执行 reactive，这其实是一种延时定义子对象响应式的实现，在性能上会有一定的提升。

涉及面试题：Proxy 可以实现什么功能？

在 Vue3.0 中将会通过 Proxy 来替换原本的 Object.defineProperty 来实现数据响应式。 Proxy 是 ES6 中新增的功能，它可以用来自定义对象中的操作。

const p = new Proxy(target, handler)

target 代表需要添加代理的对象，handler 用来自定义对象中的操作，比如可以用来自定义 set 或者 get 函数。

接下来我们通过 Proxy 来实现一个数据响应式

let onWatch = (obj, setBind, getLogger) => {
  let handler = {
    get(target, property, receiver) {
      getLogger(target, property)
      return Reflect.get(target, property, receiver)
    },
    set(target, property, value, receiver) {
      setBind(value, property)
      return Reflect.set(target, property, value)
    }
  }
  return new Proxy(obj, handler)
}

let obj = { a: 1 }
let p = onWatch(
  obj,
  (v, property) => {
    console.log(`监听到属性${property}改变为${v}`)
  },
  (target, property) => {
    console.log(`'${property}' = ${target[property]}`)
  }
)
p.a = 2 // 监听到属性a改变
p.a // 'a' = 2

8. React

必须要会的 50 道 React 面试题

9. Node

为什么用 Nodejs，它有哪些优缺点 ？

优点

• 事件驱动，通过闭包很容易实现客户端的生命活期。
• 不用担心多线程，锁，并行计算的问题
• V8 引擎速度非常快
• 对于游戏来说，写一遍游戏逻辑代码，前端后端通用

缺点

• nodejs 更新很快，可能会出现版本兼容
• nodejs 还不算成熟，还没有大制作
• nodejs 不像其他的服务器，对于不同的链接，不支持进程和线程操作

什么是错误优先的回调函数 ？

错误优先(Error-first)的回调函数（Error-First Callback）用于同时返回错误和数据。
第一个参数返回错误，并且验证它是否出错；其他参数返回数据。

fs.readFile(filePath, function(err, data) {
  if (err) { 
    //handle the error
  } 
  // use the data object 
});

如何避免回调地狱 ？

以下方式避免回调地狱

• 模块化：将回调函数转换为独立的函数
• 使用流程控制库，例如 [aync]
• 使用 Promise
• 使用 aync/await

如何用 Node 监听 80 端口 ?

• 这题有陷阱！在类 Unix 系统中你不应该去监听 80 端口，因为这需要超级用户权限。因此不推荐让你的应用直接监听这个端口。
• 目前，如果你一定要让你的应用 80 端口的话，你可以有通过在 Node 应用的前方再添加一层反向代理（例如 nginx）来实现，如下图。否则，建议你直接监听大于 1024 的端口
• 方向代理指的是以代理服务器来接收 Internet 上的连接请求，然后将请求转发给内部网络上的服务器， 并且将服务器返回的结果发送给客户端。

什么是事件循环 ？

• Node 采用的是单线程的处理机制(所有的 I/O 请求都采用非阻塞的工作方式)，至少从 Node.js 开发者的角度是这样的。而在底层，Node.js 借助 libuv 来作为抽象封装层，从而屏蔽不同操作系统的差异，Node 可以借助 livuv 来实现线程。下图表示 Node 和 libuv 的关系。
  

• Libuv 库负责 Node API 的执行。它将不同的任务分配给不同的线程，形成一个事件循环，以异步的方式将任务的执行结果返回给 V8 引擎。可以简单用下面这张图来表示。
  

• 每一个 I/O 都需要一个回调函数 ----- 一旦执行完便堆到事件循环上用于执行。

10. HTTPS

HTTP 是什么?

• HTTP 是基于 TCP/IP（传输控制协议/因特网互联协议，又名网络通讯协议，是 Internet 最基本的协议）的关于数据如何在万维网中如何通信的协议。
• HTTP 的底层是 TCP/IP。

所以 GET 和 POST 的底层也是 TCP/IP，也就是说，GET/POST 都是 TCP 链接。
GET 和 POST 能做的事情是一样一样的。你要给 GET 加上 request body，给 POST 带上 url 参数，技术上是完全行的通的。

• 业界不成文的规定是，(大多数) 浏览器通常都会限制 url 长度在 2K 个字节，而(大多数)服务器最多处理 64K 大小的 url。超过的部分，恕不处理。

• 如果你用 GET 服务，在 request body 偷偷藏了数据，不同服务器的处理方式也是不同的，有些服务器会帮你卸货，读出数据，有些服务器直接忽略，所以，虽然 GET 可以带 request body，也不能保证一定能被接收到哦。

• GET 和 POST 本质上就是 TCP 链接，并无差别。但是由于 HTTP 的规定和浏览器/服务器的限制，导致他们在应用过程中体现出一些不同。

• 关于三次握手和四次挥手，面试官想听到怎样的回答？

• 跟着动画来学习TCP三次握手和四次挥手

HTTP 中 GET 与 POST 的区别

• GET 在浏览器回退时是无害的，而 POST 会再次提交请求。
• GET 产生的 URL 地址可以被 Bookmark，而 POST 不可以。
• GET 请求会被浏览器主动 cache，而 POST 不会，除非手动设置。
• GET 请求只能进行 url 编码，而 POST 支持多种编码方式。
• GET 请求参数会被完整保留在浏览器历史记录里，而 POST 中的参数不会被保留。
• GET 请求在 URL 中传送的参数是有长度限制的，而 POST 么有。
• 对参数的数据类型，GET 只接受 ASCII 字符，而 POST 没有限制。
• GET 比 POST 更不安全，因为参数直接暴露在 URL 上，所以不能用来传递敏感信息。
• GET 参数通过 URL 传递，POST 放在 Request body 中。

GET 和 POST 还有一个重大区别

简单的说：

• GET 产生一个 TCP 数据包;
• POST 产生两个 TCP 数据包。

长的说：

• 对于 GET 方式的请求，浏览器会把 http header 和 data 一并发送出去，服务器响应 200 (返回数据);
• 而对于 POST，浏览器先发送 header，服务器响应 100 continue，浏览器再发送 data，服务器响应 200 ok(返回数据)。

据研究，在网络环境好的情况下，发一次包的时间和发两次包的时间差别基本可以无视。
而在网络环境差的情况下，两次包的 TCP 在验证数据包完整性上，有非常大的优点。
并不是所有浏览器都会在 POST 中发送两次包，Firefox 就只发送一次。

浏览器缓存实现原理

浏览器缓存将文件保存在客户端，好的缓存策略可以减少对网络带宽的占用，可以提高访问速度，提高用户的体验，还可以减轻服务器的负担。

当一个客户端请求 web 服务器, 请求的内容可以从以下几个地方获取：服务器、浏览器缓存中或缓存服务器中。这取决于服务器端输出的页面信息。页面文件有三种缓存状态。

1. 最新的：选择不缓存页面，每次请求时都从服务器获取最新的内容。
2. 未过期的：在给定的时间内缓存，如果用户刷新或页面过期则去服务器请求，否则将读取本地的缓存，这样可以提高浏览速度。
3. 过期的：也就是陈旧的页面，当请求这个页面时，必须进行重新获取。

页面的缓存状态是由 http header 决定的，一个浏览器请求信息，一个是服务器响应信息。

主要包括 Pragma: no-cache、Cache-Control、 Expires、 Last-Modified、If-Modified-Since。

其中 Pragma: no-cache 由 HTTP/1.0 规定，Cache-Control 由 HTTP/1.1 规定。

Cache-Control 的主要参数：

• A、Cache-Control: private/public，Public 响应会被缓存，并且在多用户间共享。 Private 响应只能够作为私有的缓存，不能在用户间共享。
• B、Cache-Control: no-cache，不进行缓存。
• C、Cache-Control: max-age = x，缓存时间，以秒为单位。
• D、Cache-Control: must-revalidate，如果页面是过期的，则去服务器进行获取。

Expires：显示的设置页面过期时间。

Last-Modified：请求对象最后一次的修改时间，用来判断缓存是否过期，通常由文件的时间信息产生。

If-Modified-Since：客户端发送请求附带的信息，指浏览器缓存请求对象的最后修改日期，用来和服务器端的 Last-Modified 做比较。

一文读懂前端缓存（好文）

说一下 HTTP 协议头字段说上来几个，是否尽可能详细的掌握 HTTP 协议。

HTTP 协议头字段

• HTTP 的头域包括 通用头，请求头，响应头和实体头 四个部分。
• 每个头域由一个域名，冒号（:）和域值三部分组成。
• 域名是大小写无关的，域值前可以添加任何数量的空格符，头域可以被扩展为多行，在每行开始处，使用至少一个空格或制表符。

HTTP 协议

• HTTP 是超文本传输协议的缩写，它用于传送 WWW 方式的数据。
• HTTP 协议采用了请求/响应模型。
• 客户端向服务器发送一个请求，请求头包含请求的方法、URI、协议版本、以及包含请求修饰符、客户 信息和内容的类似于 MIME 的消息结构。
• 服务器以一个状态行作为响应，相应的内容包括消息协议的版本，成功或者错误编码加上包含服务器信息、实体元信息以及可能的实体内容。

一次完整的 HTTP 事务是怎样的一个过程 ？

• 域名解析
• 发起 TCP 的 3 次握手
• 建立 TCP 连接后发起 http 请求
• 服务器响应 http 请求，浏览器得到 html 代码
• 浏览器解析 html 代码，并请求 html 代码中的资源（如 js、css、图片等）
• 浏览器对页面进行渲染呈现给用户

详情过程请看：面试题之从敲入 URL 到浏览器渲染完成

HTTP 状态码知道哪些 ？

• 100 Continue 继续，一般在发送 post 请求时，已发送了 http header 之后服务端将返回此信息，表示确认，之后发送具体参数信息。
• 200 OK 正常返回信息 。
• 201 Created 请求成功并且服务器创建了新的资源 。
• 202 Accepted 服务器已接受请求，但尚未处理 。
• 301 Moved Permanently 请求的网页已永久移动到新位置。
• 302 Found 临时性重定向。
• 303 See Other 临时性重定向，且总是使用 GET 请求新的 URI。
• 304 Not Modified 自从上次请求后，请求的网页未修改过。
• 400 Bad Request 服务器无法理解请求的格式，客户端不应当尝试再次使用相同的内容发起请求。
• 401 Unauthorized 请求未授权。
• 403 Forbidden 禁止访问。
• 404 Not Found 找不到如何与 URI 相匹配的资源。
• 500 Internal Server Error 最常见的服务器端错误。
• 503 Service Unavailable 服务器端暂时无法处理请求（可能是过载或维护）。

axios 的特点有哪些 ？

• axios 是一个基于 promise 的 HTTP 库，支持 promise 的所有 API
• 它可以拦截请求和响应
• 它可以转换请求数据和响应数据，并对响应回来的内容自动转换为 json 类型的数据
• 它安全性更高，客户端支持防御 XSRF

相关文章：

• TCP 协议和 UDP 协议的特点和区别
• (纯干货)HTTP／1.0／1.1／2.0的区别以及http和https的区别
• http & https & http2.0

11. 数据结构与算法

实现两个变量交换值的方法有哪些 ？

一、使用临时变量的方法

var t; 
t = a; 
a = b; 
b = t;

首先把 a 的值存储到临时变量中， 
然后 b 赋值给 a， 
最后拿出临时变量中的 a 值赋给 b。

二、一次加，两次减

a = a + b; 
b = a - b; 
a = a - b;

让 a 先变成 a 与 b 的 ‘和’（也可以换成 a 和 b 的差，一样的）， 
‘和’ 减去 b ，巧妙的得到了 a 的变量值赋予 b ，
再通过 ‘和’ 减去 a 的值，得到了 b 的值赋予 a 。

三、复用对象 

把 a 先变成了一个对象， 
这个对象保存着应该交换后的键值对， 
最后赋值搞定。

a = { a: b, b: a }; 
b = a.b; 
a = a.a;

四、利用数组

和上面的方法很像，只不过对象换成了数组。

a = [a, b]; 
b = a[0]; 
a = a[1];

五、一行代码

简单粗暴一行代码交换了 a 和 b 的变量值。

a = [b, b = a][0];

根据运算符优先级，首先执行 b = a ，
此时的 b 直接得到了 a 的变量值 ，
然后一步数组索引让 a 得到了 b 的值（简直不能再厉害）。

六、ES6 的解构赋值语法 

最后我的方案是利用了 ES6 的解构赋值语法， 
它允许我们提取数组和对象的值，对变量进行赋值 （旧版本浏览器不能使用ES6语法）。

[a, b] = [b, a];

原生 js 实现斐波那契数列

说明：
斐波那契数列，以兔子的繁殖的例子而引入，故又称“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、...；
在数学上，斐波那契数列以如下被以递归的方法定义：F(1)=1, F(2)=1, F(n)=F(n-1)+F(n-2)  (n>2，n∈N*)。

一、递归方法

function f(n) {
  if (n === 1 || n === 2){
    return 1;
  } else {
    return f(n-1) + f(n-2);
  }
}
console.log(f(6));

二、动态规划方法（性能得到优化）

function f(n) {
    let n1 = 1,
        n2 = 1,
        sum = 1;
    for(let i = 3; i <= n; i += 1) {
        sum = n1 + n2;
        n1 = n2;    // 往后移动一位数
        n2 = sum
    }
    return sum
}
console.log(f(5));

求一个数组的最大差值

原理：遍历一次数组，找到最大值和最小值，返回差值

var getMaxProfit = function(arr){
  // 定义两个变量，分别存贮最大值和最小值
  let maxNum = arr[0];
  let minNum = arr[0];
  for(let i = 0; i < arr.length; i++){
    if(arr[i] > maxNum){
      maxNum = arr[i];
    }
    if(arr[i] < minNum){
      minNum = arr[i];
    }
  }
  return maxNum - minNum;
}

var max = Math.max.apply(null, array)，这样就可以轻易的得到一个数组中最大的一项
注：在调用 apply 的时候第一个参数给了一个 null，这个是因为没有对象去调用这个方法，我们只需要用这个方法帮我们运算，得到返回的结果就行，所以就直接传递了一个 null 过去。

实现类似 getElementsByClassName 的功能

自己实现一个函数，查找某个 DOM 节点下面的包含某个 class 的所有 DOM 节点？不允许使用原生提供的 getElementsByClassName、querySelectorAll 等原生提供 DOM 查找函数。

function queryClassName(node, name) {  
  var starts = '(^|[ \n\r\t\f])',
       ends = '([ \n\r\t\f]|$)';
  var array = [],
        regex = new RegExp(starts + name + ends),
        elements = node.getElementsByTagName("*"),
        length = elements.length,
        i = 0,
        element;

    while (i < length) {
        element = elements[i];
        if (regex.test(element.className)) {
            array.push(element);
        }
        i += 1;
    }
    return array;
}

随机生成指定长度的字符串

实现一个算法，随机生成指制定长度的字符串。比如给定 长度 8，输出 4ldkfg9j。

原理：可以手动指定字符库及随机字符长度 n，利用 Math.floor() 和 Math.random() 两个方法实现获取随机字符。

function randomString(n) {  
  let str = 'abcdefghijklmnopqrstuvwxyz9876543210';
  let tmp = '',
      i = 0,
      l = str.length;
  for (i = 0; i < n; i++) {
    tmp += str.charAt(Math.floor(Math.random() * l));
  }
  return tmp;
}
module.exports = randomString;

判断一个单词是否是回文 ？

回文是指把相同的词汇或句子，在下文中调换位置或颠倒过来，产生首尾回环的情趣，叫做回文，也叫回环。比如 mamam redivider 。

很多人拿到这样的题目非常容易想到用 for 将字符串颠倒字母顺序然后匹配就行了。

其实重要的考察的就是对于 reverse 的实现。

其实我们可以利用现成的函数，将字符串转换成数组，这个思路很重要，我们可以拥有更多的自由度去进行字符串的一些操作。

function checkPalindrom(str) {  
    return str == str.split('').reverse().join('');
}

二分查找算法

建立在已经排好序的情况下

function binarySearch(arr, data) {
    var end = arr.length - 1,
        start = 0;

    while (start <= end) {
        var middle = Math.floor((start + end) / 2);
        if (arr[middle] > data) {
            end = middle - 1;
        } else if (arr[middle] < data) {
            start = middle + 1;
        } else {
            return middle;
        }
    }
    return -1;

}
var arr = [1, 2, 3, 4, 5, 6];
console.log(binarySearch(arr, 2));

写一个方法将数组换成前端更易解析的树状结构

function getTree(data) {
    var newData = [],
        hash = {};
    for (var i = 0; i < data.length; i++) {
        if (!hash[data[i].province]) {
            hash[data[i].province] = {
                'province': data[i].province
            };
            hash[data[i].province]['city'] = [{
                'name': data[i].city,
                'code': data[i].code
            }]
            newData.push(hash[data[i].province]);
        } else if (hash[data[i].province].province == data[i].province) {
            hash[data[i].province]['city'].push({
                'name': data[i].city,
                'code': data[i].code
            })
        }
    }
    return newData;
}
 
var data = [{
    'province': '浙江',
    'city': '温州',
    'code': '10010'
}, {
    'province': '浙江',
    'city': '杭州',
    'code': '10011'
}, {
    'province': '安徽',
    'city': '合肥',
    'code': '10012'
}, {
    'province': '安徽',
    'city': '马鞍山',
    'code': '10013'
}, {
    'province': '浙江',
    'city': '宁波',
    'code': '10014'
}];
console.log(getTree(data));

数组去重

一、 使用 ES6 的 Set 去除数组的重复元素

Array.from() 方法可以将 Set 结构转化为数组结构

function dedupe(array) { 
  return Array.from(new Set(array)); 
} 
dedupe([1, 2, 3, 3]);

二：扩展运算符（…），内部使用 for…of 循环

let arr = [1, 2, 3, 3];
let unique = [...new Set(arr)];

三：采用对象数组方法去重

function sort(arr){
    let obj = {};
    let newArr = [];
    for(let i = 0; i < arr.length; i++){
        if(!obj[arr[i]]){
            obj[arr[i]] = 1;
            newArr.push(arr[i]);
        }
    }
    return newArr;
}

字符串反转

1、split() 字符串转成数组；
2、reverse() 翻转数组；
3、join() 数组转化成字符串。

function reverse(str){
    for(let i = 0; i < str.length; i++){
        return str.split('').reverse().join('');
    }
}

产生随机数

function random(n){
    let str = '123asdasdasrwer';
    let obj = '';
    var l = str.length;
    for(let i = 0; i < n; i++){
       return obj += str.charAt(Math.floor(Math.random()*l));
    }
}

获取地址栏中某个参数的值

function getUrl(){
    let url = window.location.href();
    let Url = url.split('?');
    if(Url[0] == url){
        return '';
    }
    let obj = {};
    let arr = Url[1].split('&');
    for(let i = 0; i < arr.length; i++){
       let arg = arr[i].split('=');
        obj[arg[0]] = arg[1];
    }
    return obj;
}
var href = getUrl();
console.log(href['name']);

统计字符中出现次数最多的字母

原理：这个和数组去重类似，也是利用一个对象 obj，将数组元素作为对象的属性名，如果不存在该属性名，则值赋为 1，如果存在，则值加 1。

function findMaxDuplicateChar(str) {
    if(str.length == 1) {
        return str;
    }
    let charObj = {};
    for(let i = 0; i < str.length; i++) {
        // 利用String的charAt()方法获取各个字符; charAt() 方法可返回指定位置的字符
        if(!charObj[str.charAt(i)]) {
            charObj[str.charAt(i)] = 1;
        }else{
            charObj[str.charAt(i)] += 1;
        }
    }
    let maxChar = '',
            maxValue = 1;
    for(var k in charObj) {
        // 在obj对象中寻找值最大的那个属性
        if(charObj[k] >= maxValue) {
            maxChar = k;
            maxValue = charObj[k];
        }
    }
    return maxChar;
}

101 个硬币中有 100 真、1 假，真假区别在于重量。请用无砝码天平称两次给出真币重还是假币重的结论

方法 1

• 第一步：把硬币分为三堆儿（50，50，1），先拿两个 50 放天平比较，如果相等，说明那个单个的就是假的，再随便拿一个真硬币和这个假硬币放天平比较一下就可得到结果。
• 第二步：如果第一步的两个 50 比较后不相等，此时一端 50 重，一端 50 轻。如果拿轻的一端 50，分成两堆（25，25） 放到天平上，如果这两个 25 相等，则假硬币（重）在重的一端 50 里，否则（不相等）假硬币（轻）在这两个（25，25）里，也就是轻的一端 50 里。

方法 2

• 把硬币分为 A B C 三组，满足如下条件：C > A = B，先比较 A 和 B。如果 A 和 B 一样重，则敏感词在 C 中。
• 从 A+B 中选取和 C 同样数量的真币和 C 比较。
• 如果 A 和 B 重量不等，说明 C 中全为真币，从 C 中选取和 A 一样数量的真币与 A 比较，再结合之前 A B 比较的结果，即可得知敏感词究竟比真币重还是轻。

• 查找两个不同元素最近的父节点

JavaScript 数据结构

• JavaScript 数据结构与算法之美 - 线性表（数组、栈、队列、链表）

• JavaScript 数据结构与算法之美 - 栈内存与堆内存 、浅拷贝与深拷贝

• JavaScript 数据结构与算法之美 - 非线性表中的树、堆是干嘛用的 ？其数据结构是怎样的 ？
  

十大经典排序算法

• JavaScript 数据结构与算法之美 - 十大经典排序算法汇总

12. Git

Git 的 4 个阶段的撤销更改

电报贴纸是他们自己的世界，人们可以用酷炫的图形、垃圾模因或电影引述进行整个对话。这在很大程度上是可能的，因为 Telegram 允许您制作自己的贴纸。

制作 Telegram 贴纸的最大好处是您不必拥有开发者帐户或通过漫长而痛苦的审查。您只需将图像发送到机器人即可。

因此，如果您一直想用您和您的朋友积累的所有内部笑话做点什么，请按照本指南解释如何制作 Telegram 贴纸。

第 1 步：准备好你的贴纸

• 电报贴纸必须是 PNG 图像，具有透明背景，并且必须为 512 x 512 像素。
• 每个贴纸应该是一个单独的图像文件。
• 贴纸包的图标是可选的。如果您想要一个，请设计一个带有透明层的 100 x 100 PNG 图像。

重要的是要明白，使用电影台词之类的东西来制作贴纸是一种侵犯版权的行为。是的，这正是模因的制作方式，但与模因不同，如果版权所有者提出投诉，您的贴纸包可能会从 Telegram 上撤下。也就是说，上传设计时似乎没有版权检查。

Telegram 贴纸包平均包含 10 到 20 个贴纸，但您要上传的贴纸数量不受限制。有些包有 100 多个贴纸，即使在发布后，您也可以继续回来添加新贴纸。

第 2 步：找到 Telegram Sticker Bot

一旦您自己的 Telegram 贴纸准备好了，请找到Telegram 贴纸机器人。@stickers
单击聊天，您将看到可以使用的命令列表：

• /newpack 创建一个新的 Telegram 贴纸包。
• /addsticker 将贴纸添加到现有包。
• /delsticker 从包中删除贴纸。
• /ordersticker 重新排序包中的贴纸。
• /stats 获取特定贴纸的使用统计信息。
• /top 以查看您包中的顶部贴纸。
• /packstats 获取贴纸包的使用统计信息。
• /packtop 查看您的顶级贴纸包。
• /cancel 取消您刚刚使用的任何命令。

单击 /newpack 开始设置您的贴纸包。

第 3 步：上传您的电报贴纸

Telegram 贴纸机器人可以轻松上传和发布您的设计。您需要执行以下操作：

1. 输入/newpack命令并按键盘上的 Enter 键。
2. 贴纸机器人会询问您的背包名称。输入名称并发送。
3. 现在单击文件图标上传您的第一个贴纸。将其作为文件而不是照片上传很重要。如果您使用相机图标，机器人将拒绝图像。
4. 机器人会要求您为贴纸分配表情符号。选择与此贴纸最匹配的表情符号，然后按 Enter发送。您可以分配一些，但 Telegram 建议每个贴纸不要超过两个表情符号。
5. 对要添加的每个 Telegram 贴纸重复步骤 3-4。
6. 完成后，输入/publish命令并发送。
7. 如果您想为贴纸包添加图标，请像上传其余图像一样上传它并将其发送给机器人。如果您没有图标，只需发送/skip命令，您的第一个贴纸将成为此包的图标。
8. 最后，向机器人发送一个短名称，用于在其 URL 中使用的贴纸包。例如，这里使用的是“经典爱丽丝”，因此 URL 是

完毕！单击指向 Telegram 贴纸包的链接以查看所有内容。如果您有 10 个以上的贴纸，您可以滚动浏览它们。

开始发送您的电报贴纸
Telegram 没有贴纸商店或任何其他方式供人们浏览所有现有贴纸。这意味着您的背包将积满灰尘，直到您和您的朋友开始发送您制作的贴纸。

1.你是从什么时候看到自己成长的轨迹的？第一次打工存钱、第一次旅行、第一次染发、第一次失恋、第一次听懂某句歌词、第一次尝到眼泪的咸、第一次想家。在那个夏天的告别式后，把一部分的自己永远遗留在时间里，盖上相册后不再有翻开的理由。而后来你开始为了想要达到社会的标准奔向拥挤人潮，开始介怀身边人的目光，开始把自己和获得更多认同的人作比较，开始用物质去填满生活，但却更加空虚。你仍是在为自己而活吗？

2.我们都是拥有太多秘密的人，瓶子满泻时才想起要把快要腐烂的内里倒掉。每个人之间都隔着一个个隐形的高墙，不靠得太近也不离得太远，距离让我们能用最舒适的状态相处，不会感觉被侵占或冒犯。有人敲门，愿意让他走进的话才打开门。

3.走了千万里路寻找一个让你感觉像家的人，雨打下的时候却没有人为你撑伞，天冷的时候也没有人给你织围巾或倒上杯热茶，才发现成长就是要你学会独自行走。太深的夜偶尔抬起头看到孤悬的月，会突然不知道自己在做什么，到底想走到哪里去。好像一直都对自己不满却又无从改变。灯火万家，你感觉荒凉。你是个破了个缺口的瓶子，盼望着有谁来把你填满，却一次又一次地落空。对世界一次又一次地失望后，你什么时候才学会不对任何人报以期待。

4.有些人很久没见仍像不曾分别，有些人渐行渐远变得无话可说。生命里擦肩而过的人太多了，你不能奢求也无须留住所有人，我们都有彼此的生活，身边有彼此相同频率的人，价值观相同的人。介怀的人少了，每个人之间的连结却更深，我想，我们都变得更加成熟、更加懂得生存之道了。我们总要舍弃一些去换取更好的一些。最近认识了些新的人，看到每个人身上都有独特的光亮，都有值得去学习的地方。有时候会觉得自己的世界过于狭隘，很多事情都只是口说无凭，总是下不了决心去实行。所以我总是喜欢跟不同人交谈，每次都能窥探到新世界的一角，告诉自己还是要勇敢踏出每一步。

5.你说要无坚不摧地行走，直到没有人能肆意伤害你，尽管一路上会走失很多人，丢失一小部分的自己，会吃很多的苦，做很多或许对或许错的决定，遇到一些真心或假意的人。最后，我希望你找到自己。hey,I hope you find yourself.找到自己最舒适的状态，做一个爱恨分明的人也没关系，永远跟随内心的声音走。因为你就是这样的人。⁡只要那是你的选择，那就不要回头。

如果你只跟别人发一句 在吗，就不要指望会有答案。
相反，如果你能够直接把你的问题或者信息发出来，其它人就可以在他们有时间的时候，迅速对你的问题做出有价值的回应。

2021-07-19 17:32:12 你: 在吗
2021-07-19 17:32:16 好友: 在
[你的好友正在等待你发问题... 2分钟后]
2021-07-19 17:34:01 你: 我在调试服务的时候遇到了 xxx 报错，这种情况下要怎么做呢？
2021-07-19 17:35:21 好友: 这样啊，你应该...

这就像某个人给你打电话，说 “喂”，然后晾着你2分钟，再开始说话！这种情况下换做是你，你会急吗？

当别人看到你发一句 在吗，然后半天或者根本不进一步描述你遇到的问题的时候，他也会是这个想法。

那如果换成这样呢？

2021-07-19 17:32:12 你: 我在调试服务的时候遇到了 xxx 报错，这种情况下要怎么做呢？
2021-07-19 17:32:53 好友: [问题的答案]

看到了吗？整整节约了三分钟！

与先说在吗？相反，如果你直接把你的问题描述出来，你的好友可以马上开始考虑你的问题，这可以加快获得答案的进度。

你说在吗？，可能是不知道是否有人能够立刻回答你。但聊微信/QQ不属于这种情况。打字要比说话慢得多，你不能指望有人就是碰巧在线，并且在不知道你要干嘛的情况下乐意听你说下去。

这种情况下，与其说是询问，说在吗更像是在无意义地晾着别人，让别人等着你来表达你的问题，这样就导致了底下的效率。

同样，“你好，在吗？”，“嗨，问大家一个问题”，“有时间吗？”也都不要说。只要问问题就可以了！

此外，如果你觉得直接问问题太粗鲁无礼，那你可以把问候语放到问题的前面，如：

2021-07-19 17:32:12 你: 在吗大佬，我想问一下，我在调试服务的时候遇到了 xxx 报错，这种情况下要怎么做呢？

或

2021-07-19 17:32:12 你: 您好，我想请教一下，我在调试服务的时候遇到了 xxx 报错，这种情况下要怎么做呢？

换句话说，在别人给你回应之前先表达你的问题，能够使整个交流过程“异步化”。如果对方不在，而你要在他们回来之前离开，那么对方仍然可以在回来之后立刻回答你的问题，而不是盯着一句“在吗”然后对你要干啥一无所知。

禁止别人直接通过IP访问网站，在nginx的server配置文件前面加上如下的配置，如果有通过IP直接访问的，直接拒绝连接(需要去掉别的server下的default_server)。

server {
 listen 80 default_server;
 return 444;
}

在修改Nginx的配置之前务必做好备份，修改完后要重载一次Nginx否则不会生效。

规则里返回444状态码而不是403因为444状态码在Nginx中有特殊含义。Nginx的444状态是直接由服务器中断连接，不会向客户端再返回任何消息，比返回403更加的简单粗暴。

瞬间 2021 年也就过去了，我也还是按照常规做一个我自己的 2021 年的年终总结吧。 有人说年终总结是来凡尔赛的，可能确实有人的年终总结是故意的炫耀吧，但我觉得更多人的只是来对过去的一年画上一个句号，并期盼新一年的开始。 而且，记录下来，多年之后能回忆起来 2021 年发生的种种事情，也是一种财富吧。

- Thank you Shier for your two years of company.

• Have made or more new friends this year.

影视

书籍

《JavaScript高级程序设计（第4版）》

《JavaScript设计模式与开发实践 》

《你不知道的JavaScript（上卷）》

《CSS世界》

《图解TCP/IP(第5版)》

《3D数学基础：图形与游戏开发》

《精通正则表达式》

《挪威的森林》

《幸福了吗？》

《总要习惯一个人》

《愿你迷路到我身旁》

《我失去你的那一天》

《只能陪你走一程》

学习

学习有点遗憾，今年把过多时间用来刷 B 站了，虽然不会跟抖音一样令人沉迷，但是一旦看了之后还是会在不知不觉中消耗了时间，好吧，其实也可以算是沉迷（比如非常喜欢观察者网、外交部发言人办公室，青衣程蝶衣，艺术家阿克曼，当然还有罗翔说刑法等等），只是在这个过程中，也会学到一些知识，甚至我觉得对比与书来说，吸收知识的效率更高。

话说回来，这些知识，也是所谓的碎片化知识，无法带给我系统的知识，所以理性点说，就是娱乐。

记账

今年手动记录了自己所有的支出，也几乎养成了每笔消费之后的习惯性记账。

现在有那么多自动记账的App了，为什么还要自己费劲手动记账呢？确实现在几乎每一笔消费，都会被银行自动记录下来，并且还能够提供一些简单的分析、总结。但是，它们共同的缺点就是很难去兼容彼此，一旦你用不同的银行或者客户端，都有可能将你的消费打散开来。

还有人会说，写个脚本统一导入记账软件即可，这个我不否认，有些记账软件可以直接对接支付App的导出账单，甚至银行。非常便利，而我不选择的理由就是隐私，作为技术人员，我深感个人隐私泄露的可能性之高，因为数据库被拖，甚至主动卖出数据也是家常便饭了，因此，我对于国内的这帮互联网大厂，有深深的不信任感。不过，我相信在国家的介入下，法制越来越完善，行业也会越来越注重用户的隐私，真正把用户的隐私当回事，而不是以用户会用隐私换取便利。

其实，之前尝试过不同的记账方式，到了最后都逐渐放弃了，因为那些记账方式，都没有让自己深度参与到其中，记账的工作被机器自动化了，以至于对于最后的账单统计也最多只会轻叹一声：「天，这个月花怎么花那么多？」。

说了半天，其实自己手动记账是一个能让自己对于花出去的每一分钱更有意识的行为，这样做，多少都会找回那种数字简单减少而产生的无动于衷的感觉。

今年记了一整年的帐后，从月账单的统计中，真正意识到了自己在过怎么样的一种生活。然而，自己还是缺乏制作并实施预算的习惯，所以，也没法去掌控自己过什么样的生活。

分手

我跟 dian. 在上个月23号和平分手了，我们没有矛盾,没有争吵,没有冷战,(我以为)没有做过任何违背对方底线的事 现在看来我只不过是她获取另外一段感情中利用的一颗的棋子，在22号晚一场内心深度的沟通之后在23号早上她跟我通了一次视频提出分手。

最后

新年快乐，博客我还会写下去的，毕竟还有那么多的朋友关注我，只是目前频率不能保持恒定了,不论新的一年来的有多快，都要慢一点去感受这美好的世间。

前言

Ng­inx (en­gine x) 是一个高性能的 HTTP 和反向代理服务，目前很大一部分网站均使用了 Ng­inx 作为 WEB 服务器，Ng­inx 虽然非常强大，但默认情况下并不能阻挡恶意访问，这里有一份常用的 Ng­inx 屏蔽规则，希望对你有所帮助。

在开始之前，希望您已经熟悉 Ng­inx 常用命令（如停止、重启等操作）及排查 ng­inx 错误日志，以免出现问题不知所措。如无特殊注明，以下的命令均添加到 server 段内， 修改 nginx 配置之前务必做好备份，修改完毕后需要重载一次 nginx，否则不会生效。

防止文件被下载

比如将网站数据库导出到站点根目录进行备份，很有可能也会被别人下载，从而导致数据丢失的风险。以下规则可以防止一些常规的文件被下载，可根据实际情况增减。

location ~ \.(zip|rar|sql|bak|gz|7z)$ {
  return 444;
}

屏蔽非常见蜘蛛（爬虫）

如果经常分析网站日志你会发现，一些奇怪的 UA 总是频繁的来访问网站，而这些 UA 对网站收录毫无意义，反而增加服务器压力，可以直接将其屏蔽。

if ($http_user_agent ~* (SemrushBot|python|MJ12bot|AhrefsBot|AhrefsBot|hubspot|opensiteexplorer|leiki|webmeup)) {
     return 444;
}

禁止某个目录执行脚本

比如网站上传目录，通常存放的都是静态文件，如果因程序验证不严谨被上传木马程序，导致网站被黑。以下规则请根据自身情况改为您自己的目录，需要禁止的脚本后缀也可以自行添加。

#uploads|templets|data 这些目录禁止执行PHP
location ~* ^/(uploads|templets|data)/.*.(php|php5)$ {
    return 444;
}

屏蔽某个IP或IP段

如果网站被恶意灌水或 CC 攻击，可从网站日志中分析特征 IP，将其 IP 或 IP 段进行屏蔽。

#屏蔽192.168.5.23这个IP
deny 192.168.5.23;
#屏蔽192.168.5.* 这个段
deny 192.168.5.0/24;

其它说明

再次强调，修改 nginx 配置之前务必做好备份，修改完毕后需要重载一次 nginx，否则不会生效。

上面大部分规则返回 444 状态码而不是 403，因为 444 状态码在 ng­inx 中有特殊含义。ng­inx 的 444 状态是直接由服务器中断连接，不会向客户端再返回任何消息，比返回 403 更加暴力。若有不足还请补充和指正。

该方法可能存在风险，如因此账号被封与我无关

该方法可能存在风险，如因此账号被封与我无关

该方法可能存在风险，如因此账号被封与我无关

找到英雄联盟的安装目录后进入 TCLS 目录在里面找到一个叫 wegame_launch.tmp 的文件，用记事本打开把里面的内容修改为

[TCLS]
LocalR=88
LastLoginMethod=1

太宰治在《人间失格》中写过这样一句话：

“ 仅一夜之间，我的心判若两人，她自人山人海中而来，原来只为给我一场空欢喜，你来时携风带雨，你走时乱了四季，我久病难医。 “

在感情中，人们有时候不会那么幸运，一出门就能与真爱撞个满怀。

往往总要经历过一场痛苦的 “ 空欢喜 “ 后，才能明白，有些人不会因为你对他好，他便也回馈给你同样的温柔。

一个人不爱你的时候，哪怕你是天上的星星，他也依然不想占为己有。

还记得那一年的热搜，张靓颖在演唱会现场对相守12年的冯轲求婚： “ 愿意娶我，你就上台。 “

但她的破釜沉舟，换来的却是对方将近五分钟的漫长沉默。

最后，周折半天，冯轲也没说出那句 “ 我愿意 “ ，而是非常老练地说了一些应付媒体和粉丝的话。

张靓颖只能尴尬地站在台上，情绪一度快要失控。

很多人看完新闻说： “ 张靓颖太傻了，看不出一个男人不爱她。 “ 但我却觉得，张靓颖和他相处12年，并不是在求婚当天才知道对方不愿意的。

这个男人敷衍的态度，躲闪的眼神，在他们相处的过程中，她肯定能感受到。

她只是不甘心，想要利用舆论让这个男人就范而已。

但在感情中， “ 爱 “ 并不是一件你赌上所有就能获得相同回报的事情。

你可以赔上身家性命，不顾一切地去爱一个人。但要以此来维持一段感情，是远远不够的，因为爱是两个人的共同维系，而不是一个人单枪匹马地奔赴。

竭尽所能地去单向付出，最后只能感动自己，却绑不住爱情。

我见过很多不被珍惜的感情，包括我自己。

在一段错的关系里，反反复复地折磨自己、消耗自己，却换不来一个好结局。

后来我才明白，遇到一个错的人，其实你最该做的不是死撑到底，而是试着走出来，去寻找更合适的人。

就像张馨予，在遇到何捷之前，她也曾痛苦过，迷茫过，和李晨那场错误的爱情，把她消耗到一无所有，人生也跟着跌进了谷底。

直到她在《神犬奇兵》中遇到了何捷，她才感受到被宠爱成 “ 小孩 “ 的滋味。

张馨予的故事，让我想起了在网上看过的一句话：你没有和他在一起的运气，是因为你有更好的运气。

我们总以为，努力去爱一个人，是为了获得相同的回报。因此很多人在感情里为了所谓的 “ 回报 “ 而沉没更多付出。在一次次消耗中，却越来越不相信爱情。

但你要知道，就算有些人对你的付出视而不见，也不代表是你做错了什么，只是因为他不是那个对的人，而你不要因为错的人就失去相信爱的能力。

我们总要鼓起勇气和错的人挥手告别，才能腾出地方等待对的人出现。

赫本在我们眼中，是漂亮的女明星，是没有男人能抗拒的女人。

但即便是这么完美的赫本，在感情里同样也是跌跌撞撞，她也有爱不到的人，有走不通的路。

赫本一生中经历了三次爱情，第一次婚姻维持了14年，倒在了生活的鸡毛蒜皮里；第二次婚姻，维持了10年，败给了丈夫的不检点中。

直到第三次，她苦苦追寻了20多年，才遇到了她的真爱罗伯特，这次她虽然没有选择结婚，没有一纸婚书的约束，但他们却相伴余生。

你看，即便是赫本，也在爱情里碰过壁，在婚姻里吃过苦头。

但失望过后，她还是遇到了陪她走到最后的那个人。

人生中，我们总会有走错的路，爱错的人；但走错了路，要记得回头，爱错了人，要懂得放手。

你始终要相信，不管你狼狈不堪，还是满身泥泞，你终会遇到一个人，他身披金甲，脚踏彩云，只为寻你而来。

替你抹去泥泞，挡住荆棘，你看着他满脸的坚定，和温柔的爱意，从此全是最好的运气。

你说，这世上有从一而终的爱情吗？

或者说，当你的爱情被生活磨得索然无味后，你遇到了更好的人，你会如何选择？

世人总把爱情粉饰成美好的童话，可是爱情逃不开现实，更逃不过人性。

我曾经，非常相信真正的爱情是不存在 “ 同床异梦 “ 的。

但自从我结婚后，才知道爱情和现实一样，并不是无暇的乌托邦，它也会被新鲜所吸引，被人性所影响。

当爱情把新鲜耗尽后，生活只剩下毫无悬念的雷同，感情似乎变成了一场反复放映的电影，即便再精彩的剧情，也会变得毫无悬念，期待全无。

就好比，我还没起床，就知道他一定会放哪首歌洗澡；我不用多看一眼，就知道他今天要穿什么颜色的袜子上班；不用细想，就知道他肯定会在7点15分时，开门回家。

一切都那么寡淡无趣，日子是，人也是。

所以，有时候我也会想，如果这时候有个更新鲜的存在，闯入我的生活中，就算我有崇高的原则约束，心里也不免会有些许期待和想象吧。

就像人在口渴的时候不会嫌弃白开水无味，而当生活中只剩下白开水后，眼前突然出现了一瓶可乐，想不为所动就很难了。

《奇葩说》中，曾经有一期辩题是：如果你发现了伴侣开小差，容不容忍？

傅首尔有句话让我深以为然，她说： “ 不开小差的伴侣生活中只有唐僧，能天雷地火昏了头去结婚的人都是俗人，俗人无法做到完全不开小差。 “

因为感情中，除了有不可触犯的原则问题外，其实有很多像这种说不清道不明的灰色地带。

这中间总会穿插一些或意外或危险的心动，因为我们都是俗人，总会有追求 “ 新鲜 “ 的冲动。

但重要的是，追寻 “ 新鲜 “ 或许是我们作为人的天性，而忠诚却是我们对感情本能的选择。

就像在地铁里遇到很帅的男生我总会忍不住多看一眼，电视里看到很帅的明星也会脱口就叫 “ 老公 “ 。

前段时间我陪闺蜜去音乐节，途中遇到了一个男生约我下次一起玩，被我礼貌拒绝了。

或许对方并没有别的意思，他的邀请也和 “ 背叛 “ 扯不上什么道德关系，但我依旧没有太多的思考，只是下意识地拒绝，并且认为这本该如此。

感情中，我们总会不可避免地遇到一些 “ 精神小差 “ 的时刻，这是我们无法黯灭的人性，和自我精神中的小小娱乐。

当面对非黑即白的选择时，真正懂得珍惜、懂得爱的人，依旧还是会本能地选择忠诚。

如果 “ 精神小差 “ 不足以撼动选择，那当你遇到了更优秀的存在，你会如何选择呢？

之前知乎上有很多类似的提问，每次看到这样的问题，我总会想到《小王子》的故事，想起小王子在面对更多、更美丽的玫瑰花时，他并没有显得很开心或新鲜。

反而认为，即使世上有千万朵玫瑰，对于自己而言，依旧是他悉心浇灌，日日陪伴的那一朵最好。

对于小王子来说，他付出的是彼此漫长的磨合，是仅属于他们独一无二的成长。

如果让小王子再去给一朵新的玫瑰花浇水、灌溉、驱虫，我想他也做不到了吧。

因为，从零开始去适应一个人，再去磨合出彼此合适的相处模式，真的太难了。并且，你认为的 “ 更好 “ ，仅仅只是因为新鲜感的面纱，遮住了现实中的那些琐碎不堪罢了。

这世上或许会有更好的人，但永远不会有更好的爱人。

要知道，感情和现实一样，不是无暇的乌托邦，更不是故事书里的城堡。

岁月总是擅长把爱情变成反复冲泡的茶水，让你从新鲜中慢慢感到无味。

这中间或许会让你遇到更好的人，也会有更新鲜的诱惑让你开个 “ 精神小差 “ ，这没什么，你要相信，这世上每段感情都会经历一段 “ 同床异梦 “ 的时期。

就像电影《玛嘉烈与大卫 前度》中的那段话：

“ 每一对细水长流的恋人，都经历过同床异梦的阶段。白头到老同偕白首，不是传说而是一个励志故事，要开花结果最重要的是耐性。 “

我们总要经历过一些选择后，才能更明确心里的答案，更笃定自己曾经的相信，不是吗？

感情或许会逃不开现实，也逃不过人性，可它总会有变淡的那一天。

但我们心底里的深爱，却可以本能地帮我们指出同一个答案，那就是： “ 即便无法改变天性，但忠诚也是我们对彼此唯一的选择。 “

下载地址：

由于本定制系统ISO文件比较大并且存放在腾讯云的对象存储为了防止恶意刷流量需要的可以留言给我。ISO文件大约为12G；安装后大约为29G，建议使用32G以上的U盘进行安装。

本系统

Rufus工具：
https://wjxz.shimmerls.top/%E5%86%99%E7%9B%98%E5%B7%A5%E5%85%B7/rufus-4.1.exe

ISO文件不能直接安装，我们需要使用PE工具或者ISO的烧刻工具，例如Rufus

如果是PE启动盘那么直接拖到启动盘里面进入PE用安装工具进行安装即可，如你使用的是Rufus等工具请务必将镜像选项选择标准Windows安装 , 分区类型GPT , 目标系统类型UEFI , 格式化的文件系统NTFS

以下是本定制系统的所有修改，请仔细看完本篇文章

激活

已通过KMS进行激活

系统的修改

• Windows更新 - 关闭
• 添加 萍方字体
• 添加 Mac光标

组件移除

Metro 应用

• Clipchamp
• Cortana
• Microsoft To Do
• MSN Weather
• Feedback Hub
• Get Help
• 快速助手
• 提示（Win 1607之前叫"入门"）

系统应用

• 移除讲述人

桌面修改

• 任务栏—聊天：禁用
• 搜索（任务栏）：禁用
• 桌面图标 - 回收站：启用
• 桌面图标 - 控制面板：启用
• 桌面图标 - 用户文件夹：禁用
• 桌面图标 -网络：禁用
• 桌面图标 - 计算机：启用

输入法及语言

系统输入法默认模式修改为英语；默认为中文；
额外安装England（United States）语言，即英语（美国）

注意

1. C盘内的安装包文件夹可以根据自己的需求选择安装
2. 任务栏设置靠左方法：
   设置 —— 个性化 —— 任务栏行为 —— 任务栏对齐方式
3. 虽然已经把Mac光标封装进了系统，但是需要手动启用：设置 —— 个性化 —— 鼠标 —— 找到MacOS选择并确定

1. win+r打开运行
2. 输入gpedit.msc打开组策略编辑器
3. 打开组策略编辑器后,双击右侧的“计算机配置”
4. 然后双击打开“Windows 设置”文件夹
5. 然后双击打开“安全设置”选项
6. 然后双击打开“本地策略”文件夹
7. 然后双击打开“安全选项”文件夹
8. 在安全选项文件夹中，首先找到“用户账户控制：以管理员批准模式运行所有管理员”这一条双击打开,打开属性设置后，选择“已禁用” 保存
9. 然后双击下面一条“用户账户控制：用于内置管理员账户的管理员批准模式”打开，还是选择“已禁用”，关闭组策略编辑器后重新启动。

建议 (当然你也可以不接受我的建议)

1. 使用Git工具代替Windows原有的CMD / PowerShell
2. 出现问题了一定要多看 Log(日志) ，看不懂的可以复制到翻译工具上翻译一下
3. 使用一个新的文件夹搭建服务端
4. 如果服务端在你的本机上建议你在进入服务器的时候使用内网IP或127.0.0.1进入服务器，当然你也可以跟其他人一样使用公网的域名但最终还是要转发到你本机上。
5. 添加nogui参数启动服务端

开始部署

我这里以1.12.2为例，其他版本的大同小异。

下载的整合包只需要里面的Mods 文件夹其余的全部不需要并且建议复制两份，一份给客户端(无删减)，一份服务端(删减服务端不需要的)
下载的整合包只需要里面的Mods 文件夹其余的全部不需要并且建议复制两份，一份给客户端(无删减)，一份服务端(删减服务端不需要的)
下载的整合包只需要里面的Mods 文件夹其余的全部不需要并且建议复制两份，一份给客户端(无删减)，一份服务端(删减服务端不需要的)

1. 到Forge下载相应版本的服务端文件

这里需要注意的是如果你直接点击Installer按钮那么恭喜你，你已经成功的跳转到广告推广页面了我们需要在Installer按钮上鼠标右键选择复制链接按钮之后你会得到这么一串东西

https://adfoc.us/serve/sitelinks/?id=271228&url=https://maven.minecraftforge.net/net/minecraftforge/forge/1.12.2-14.23.5.2855/forge-1.12.2-14.23.5.2855-installer.jar

https://adfoc.us/serve/sitelinks/?id=271228&url=
这前面的内容是它跳转到广告推广页面的；而服务端的文件是后面的这个

https://maven.minecraftforge.net/net/minecraftforge/forge/1.12.2-14.23.5.2855/forge-1.12.2-14.23.5.2855-installer.jar

在得到了真正的服务端文件下载链接之后我们直接把下载链接粘贴到浏览器上就能开始下载了。

2. 把你下载的服务端文件放到一个干净的文件夹，并在上面的地址栏内输入cmd然后回车跳出来cmd命令窗口

如果你已安装了Git工具，请在文件夹内鼠标右键找到Git Bash Here选择并打开

还需要的注意的是 CMD/Git 中的路径是否在你的文件夹里，如上我的文件保存在桌面的111文件夹内，那他显示的就是Desktop/111同理如果你的文件夹是在D盘的mcserver文件夹里那么显示的应该是d/mcserver

3. 使用命令安装环境库

java -jar <File.jar> --installServer

命令解析：

java=使用Java

-jar=文件格式

<File.jar>=运行库的文件名

--installServer=安装服务器

​安装好的内容如下

它们分别是

libraries=运行库

1.12.2.json=版本信息

forge-1.12.2-14.23.5.2855.jar=服务端启动文件

forge-1.12.2-14.23.5.2855-installer.jar=服务端运行库安装文件

forge-1.12.2-14.23.5.2855-installer.jar.log=服务端运行库安装文件的日志

minecraft_server.1.12.2.jar=官方的服务端启动文件

4. 同意用户条款。

我们在文件夹内创建一个名为eula的TXT文本文档在里面输入eula=true然后保存关闭即可启动服务端。

5. 首次启动

输入以下命令即可启动服务端

java -Xms2G -Xmx4G -jar <File.jar> nogui

命令解析：

java= 使用Java

-Xms2G=起始内存为2G

Xmx4G=最大内存为4G

<File.jar>=服务端的文件名

nogui=这里其实是两个单词分别是no跟gui意思是不需要图形化界面，这个可以极大的减少内存占用。

当你看到Done (7.419s)! For help, type "help" or "?"的时候说明

我们在控制台输入stop或按快捷键Ctrl+C停止服务端

它们分别是

config=配置文件目录

libraries=运行库

logs=日志文件

mods=模组目录

wold=地图数据；这里需要注意的是如果你修改过server.properties文件里的参数可能不是这个名字

1.12.2.json=版本信息

banned-ips.json=封禁IP

banned-players.json=封禁玩家

eula.txt=上面同意用户条款

forge-1.12.2-14.23.5.2855.jar=服务端启动文件

forge-1.12.2-14.23.5.2855-installer.jar=服务端运行库安装文件

forge-1.12.2-14.23.5.2855-installer.jar.log=服务端运行库安装文件的日志

minecraft_server.1.12.2.jar=官方的服务端启动文件

ops.json=管理员文件

server.properties=配置文件

usercache.json=用户缓存

whitelist.json=白名单文件

我们把之前在整合包里提取的mods(服务端)直接覆盖上去并重新启动服务端。这里提示一下按 上下左右的上键可以快速返回到上一次输入过的命令

当你再次看到Done (*.***s)! For help, type "help" or "?"的时候说明你的服务器已经搭建起来了，过程中如果出现了一些红的黄的先不管。

这个时候你的文件夹里会多出来两个文件夹

CustomSkinLoader=自定义皮肤加载器

crash-reports=崩溃报告

6. 出现错误导致无法启动时查看crash-reports(崩溃报告)

下面我来说一下怎么看log它一般生成在crash-reports文件夹内一般以启动的时间命名如：crash-2021-08-23_22.31.45-server.txt里面的内容如下：

---- Minecraft Crash Report ----
    
WARNING: coremods are present:
Contact their authors BEFORE contacting forge

// Don't do that.

Time: 21-8-23 下午10:31
Description: Exception in server tick loop

Wrong Minecraft Versions!
Mod: cfm
Location: .\mods\cfm-7.0.0pre22-1.16.3.jar
Expected: [1.13,)
Current: Minecraft 1.12.2

Wrong Minecraft Versions!
Mod: farmersdelight
Location: .\mods\FarmersDelight-1.16.3-0.3.2.jar
Expected: [1.13,)
Current: Minecraft 1.12.2

Wrong Minecraft Versions!
Mod: twilightforest
Location: .\mods\twilightforest-1.16.5-4.0.490-universal.jar
Expected: [1.13,)
Current: Minecraft 1.12.2

Wrong Minecraft Versions!
Mod: worldedit
Location: .\mods\worldedit-mod-7.2.5-dist.jar
Expected: [1.13,)
Current: Minecraft 1.12.2

net.minecraftforge.fml.common.MultipleModsErrored
    	at net.minecraftforge.fml.common.Loader.sortModList(Loader.java:300)
    	at net.minecraftforge.fml.common.Loader.loadMods(Loader.java:572)
    	at net.minecraftforge.fml.server.FMLServerHandler.beginServerLoading(FMLServerHandler.java:98)
    	at net.minecraftforge.fml.common.FMLCommonHandler.onServerStart(FMLCommonHandler.java:333)
    	at net.minecraft.server.dedicated.DedicatedServer.func_71197_b(DedicatedServer.java:125)
    	at net.minecraft.server.MinecraftServer.run(MinecraftServer.java:486)
    	at java.lang.Thread.run(Unknown Source)
    
    
    A detailed walkthrough of the error, its code path and all known details is as follows:
    ---------------------------------------------------------------------------------------
    
    -- System Details --
    Details:
    	Minecraft Version: 1.12.2
    	Operating System: Windows 10 (amd64) version 10.0
    	Java Version: 1.8.0_301, Oracle Corporation
    	Java VM Version: Java HotSpot(TM) 64-Bit Server VM (mixed mode), Oracle Corporation
    	Memory: 1494856688 bytes (1425 MB) / 2058354688 bytes (1963 MB) up to 3817865216 bytes (3641 MB)
    	JVM Flags: 2 total; -Xms2G -Xmx4G
    	IntCache: cache: 0, tcache: 0, allocated: 0, tallocated: 0
    	FML: MCP 9.42 Powered by Forge 14.23.5.2855 8 mods loaded, 8 mods active
    	States: 'U' = Unloaded 'L' = Loaded 'C' = Constructed 'H' = Pre-initialized 'I' = Initialized 'J' = Post-initialized 'A' = Available 'D' = Disabled 'E' = Errored
    
    	| State | ID             | Version      | Source                                      | Signature                                |
    	|:----- |:-------------- |:------------ |:------------------------------------------- |:---------------------------------------- |
    	| L     | minecraft      | 1.12.2       | minecraft.jar                               | None                                     |
    	| L     | mcp            | 9.42         | minecraft.jar                               | None                                     |
    	| L     | FML            | 8.0.99.99    | forge-1.12.2-14.23.5.2855.jar               | e3c3d50c7c986df74c645c0ac54639741c90a557 |
    	| L     | forge          | 14.23.5.2855 | forge-1.12.2-14.23.5.2855.jar               | e3c3d50c7c986df74c645c0ac54639741c90a557 |
    	| L     | cfm            | 1.0          | cfm-7.0.0pre22-1.16.3.jar                   | None                                     |
    	| L     | farmersdelight | 1.0          | FarmersDelight-1.16.3-0.3.2.jar             | None                                     |
    	| L     | twilightforest | 1.0          | twilightforest-1.16.5-4.0.490-universal.jar | None                                     |
    	| L     | worldedit      | 1.0          | worldedit-mod-7.2.5-dist.jar                | None                                     |
    
    	Loaded coremods (and transformers): 
    	Profiler Position: N/A (disabled)
    	Is Modded: Definitely; Server brand changed to 'fml,forge'
    	Type: Dedicated Server (map_server.txt)
    ```

    别看这么多东西就怕了你只需要看`WARNING:`后面的内容即可，如上文本那我需要看的内容如下

    ```language
    // Don't do that.
    
    Time: 21-8-23 下午10:31
    Description: Exception in server tick loop
    
    Wrong Minecraft Versions!
    Mod: cfm
    Location: .\mods\cfm-7.0.0pre22-1.16.3.jar
    Expected: [1.13,)
    Current: Minecraft 1.12.2
    
    Wrong Minecraft Versions!
    Mod: farmersdelight
    Location: .\mods\FarmersDelight-1.16.3-0.3.2.jar
    Expected: [1.13,)
    Current: Minecraft 1.12.2
    
    Wrong Minecraft Versions!
    Mod: twilightforest
    Location: .\mods\twilightforest-1.16.5-4.0.490-universal.jar
    Expected: [1.13,)
    Current: Minecraft 1.12.2
    
    Wrong Minecraft Versions!
    Mod: worldedit
    Location: .\mods\worldedit-mod-7.2.5-dist.jar
    Expected: [1.13,)
    Current: Minecraft 1.12.2
    

它这里会告诉你导致出错的Mod是什么，Location它现在在什么位置，Expected它应该是什么版本，和Current你当前运行的服务端是什么版本

镜像库的使用

我个人搭建的镜像库已关闭

关于最近log4j的漏洞

1.18版本的将服务端更新1.18.1即可。

1.17.x：在启动时，添加参数

-Dlog4j2.formatMsgNoLookups=true

1.12-1.16.5的下载补丁

https://launcher.mojang.com/v1/objects/02937d122c86ce73319ef9975b58896fc1b491d1/log4j2_112-116.xml

添加参数：

-Dlog4j.configurationFile=log4j2_112-116.xml

1.7-1.11.2的下载补丁

https://launcher.mojang.com/v1/objects/dd2b723346a8dcd48e7f4d245f6bf09e98db9696/log4j2_17-111.xml

添加参数：

-Dlog4j.configurationFile=log4j2_17-111.xml

<完>

如何让电脑开机完后，顺便自启动多个程序，我们可以创建一个批处理文件，在批处理文件里放入需要启动的程序然后把批处理文件放在开机启动的文件夹里让电脑开机完自动运行。

一、首先我们在电脑任意位置创建一个txt文本文档，然后在里面输入以下命令

start "" "" & ping iocalhost -n 3

说明：如果你所在程序的路径中带有空格，那么必须用“”把路径括起来，否则系统会提示找不到文件。

二、把编辑好的命令保存后放入开机启动的文件夹中，路径如下：

C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp

如果一时找不到这个路径，可以点击资源管理器的查看、把显示隐藏的项目勾上。

Start: 启动单独的命令提示符窗口来运行指定程序或命令。
第一个双引号: 创建一个空白的窗口
第二个双引号: 它指向的程序是XXX（这里需要完整的文件路径）
&: 这是一个连接符，用于连接下一个命令
ping: ping命令，一般用于检测网络通与不通，在这里我用于这个命令来延迟下一行命令运行
iocalhost: 表示自己，这个跟127.0.0.1一样代表自己的意思
-n: 只输出数值
3: ping命令运行3次

例子:
当我想运行位于G盘的英雄联盟并且在3秒后运行位于D盘的UU加速器时，应该使用以下命令：

start "" "G:\LOLApp\英雄联盟\TCLS\Client.exe" & ping iocalhost -n 3
start "" "D:\Netease\UU\uu.exe" & ping iocalhost -n 3

这里需要注意如果你的文件夹中跟我一样存在中文的，请确保你保存的编码格式为ANSI否则是无法识别到正确的中文。

我们可以使用另存为，在保存的左边选择编码格式为ANSI

<完>

以下内容转载于 蕊希 微信公众号：蕊希

你有没有觉得， “ 忘记 “ 在感情里是个骗人的伪命题。

他的名字和生日，他的模样和喜好，怎么可能说忘就忘了呢。

你们一起做过的小事可能在时间的流转中日渐褪色，但他陪你去过的城市，情人节送你的礼物，热恋时说过的情话，却没那么容易灰飞烟灭。

分开后你的日子逐渐恢复往常，一切都有条不紊地进行着，有时候你在想其实回忆也不过如此，好多事情一旦过去，就会逐渐不再鲜明。

奇怪的是，某年某月的某一天，当撕下日历那一页后，你发现原来这一天不是平凡普通如过往的一天，你对着日历发呆，想象着他过生日的画面；

奇怪的是，打字聊天的时候，碰到关于他名字的字，你还是会有意地避开；

奇怪的是，新闻里他家乡有了什么新情况，你也会跟着开心和惦记。

我们总幻想过去的爱情如雁过无痕，最好了无踪影，但事实却是那些彼此相爱过的印记，早在不知不觉中，变成了身体记忆。

你们已经分开很久了，但总在某一刻，你会想起关于他的事情。

你们没再见过面，但他却在某一瞬间，突然蹦到你眼前，走来走去。

所以别再勉强自己不去想、不去好奇、拼命忘记了，我们都知道的，七八岁看过的动画片现在你仍然记得，初中学过的古诗文还在你脑海里，人的记忆远比想象中更长久。

真正的放下不是努力不再想起，拼命与过去划清界限，而是即便与回忆重逢，也不会乱了分寸，是即使与过去四目相对，也只剩一声平静的叹息。

爱情的痕迹不会随意被擦除，你要放下的不是过去的记忆，而是爱他的那颗心。

以下内容转载于 蕊希 微信公众号：蕊希

上个月我肩膀不舒服，在网上找了个口碑还不错的推拿店团了券。

师傅手艺挺好，但就是太热情了，不停地推销办卡，临走时还拿着手机要求交换微信。

不好意思拒绝的我，无奈同意了他添加好友的请求。

之后几天，他都坚持不懈地给我发信息推荐套餐、介绍养生知识。

一开始，我也会礼貌地用 “ 最近很忙，有时间一定光顾 “ 推辞，但他似乎没明白我的意思，依旧锲而不舍。

再加上我被工作折磨得焦头烂额，我实在没闲心、也没耐心继续应付他，所以直接把他的消息设置成了免打扰，翻手机时就算点开看，也不会回应什么了。

渐渐地，他不再给我发信息了。

我也想一直保持彬彬有礼的尊重，但他拉生意的方式确实干扰了我的正常生活。

或许很多人都遇到过类似的情况，成年人的社交中，其实存在一种状态叫 “ 已读不回 “ 。

我特别反感一些莫名其妙的开场白，尤其是在我忙得热火朝天时，很久没联系的人给我发个 “ 在么 “ 就没下文了。

我心知肚明，在或不在根本不是重点，我是很想告诉你我在，但也确实没精力一言一语地进行废话练习，这样的寒暄除了浪费时间，几乎没有任何养分。

我不是针对你、故意不回消息，而是在我眼里你压根什么都没问，只能通过 “ 已读不回 “ 的方式等待核心内容的出现。

沟通不是一个人的游戏，是至少两个人的交际，高效社会，最让人无奈的就是低效交流。

所以，我不理解为什么有的情侣每时每刻都想试探爱意：

" 你爱不爱我？ " 
" 你想不想我？ "
" 你为什么不回我信息？ " 

没秒回未必就是不爱了，也可能是眼前有需要立刻处理的问题。

爱情是细水长流的，大可不必和十万火急的事抢时间。

前几天，同事突然问我：遇到过没有任何原因，但就是单纯不想回别人消息的情况么？

她说她也知道这种行为可能不太好，但有时候就只想把空余时间留给自己，打打游戏、追追剧、看看书。

这让我想起了姜思达的一句话： “ 要求时刻保持联系，最大的危害就是难以和自己保持联系。 “

时间越长我们越能发现，在社会里混饭吃，关于人情世故的问题永远不会停歇，但我们也有权利享受短暂 “ 逃离世界的幸福 “ 。

就像机器需要充电，我们也需要自我调节、需要享受一个人的时光，只有在那段时间里我们才不必刻意成为谁的谁，而只是属于我们的自己。

所以碰到 “ 已读不回 “ ，先别瞎想，对方可能只是在自我沉淀，但如果很长时间过去了，你的热情依然没有得到回应，那就不要再等了。

没有不想回的消息，只有不想理的人。

对于重要的人，我的 “ 已读不回 “ 都是有期限的，就算当时有各种各样的情况，没回复你这件事也会在我脑子里来回乱窜，闲下来就一定会回应。

有次连夜赶工，闺蜜和我分享了新发现的八卦，我看了一眼后并没有任何举动，心想着就算回了一句，也没时间聊得尽兴，索性就不回了。

但我一直惦记着，结束工作后的第一件事就是约她吃饭，开启没来得及讨论的话题。

你看，她发给我的东西似乎也没什么意义，但我还是会把它放在心里念念不忘。

说到底，如果真的在意，又怎么会读了信息一直没反应呢？

把 “ 已读不回 “ 当成后会无期的借口，只是因为压根不在意。

有些人聊到最后没话讲，就算发个表情也要回复他；有些人发的消息即便看见了，也想装作没看见。

在乎你的人，话越聊越多；不在乎你的人，打标点都觉得累，所以对于那些无限期 “ 已读不回 “ 的人，不如一笑而过，他不珍惜你，你也不要硬耗着。

就像那句话说的一样： “ 不要在机场等一艘船，因为你根本没有等到的可能。 “

他不是对你的消息不感兴趣，而是对你这个人不感兴趣。你的温柔应该留给值得的人，最后，希望大家都能拥有对等的社交关系。

每个人都会有不想回消息的时候，在某个时间段里只想自己和自己相处。所以，我们不必苛求对方必须秒回，但如果对方超过24小时，甚至超时间不理会你，那你也要记得及时抽身。毕竟，一扇确定不会为你而开的门，一直敲是没礼貌的。

前段时间更换图床图片全没了以后再补上吧！

需要材料

1. 下载微软官方安装工具
2. 一个≥ 16GB的U盘

提示：在格式化硬盘/U盘前请做好数据备份 数据无价，谨慎操作。

开始

一. 创建U盘镜像

1. 到微软官网下载安装工具
   官网地址：https://www.microsoft.com/zh-cn/software-download/windows10/
   

2. 下载完成后打开安装工具并插入U盘，开始会让你同意一个协议，点击接受即可
   

3. 选择为另一台电脑创建安装介质
   

4. 选择语言跟体系结构，这里默认即可
   

5. 选择要安装的介质为U盘
   

6. 选择你插入的U盘
   
   注意：这里选择盘的时候一定要看清楚，一旦选错相应的盘将立刻被格式化，一定要看清楚选择的是否正确，我这里因为插了一块移动硬盘一个U盘所以显示两个，如果你只插了一个U盘理论上只会显示一个

7. 等待它自动完成即可
   

8. 看到该页面代表U盘创建成功
   

9. 点击完成后会清理文件，我们不用管它清理完成后它会自动关闭
   

二. 开始安装

1. 重启电脑按主板快捷键选择引导盘为U盘（我这里因为使用的是虚拟机所以跟你们的BIOS不太一样）
   
   接下来会看到熟悉的Windows启动Logo我们稍等片刻
   
   看到此界面就可以开始安装系统了，选择你的语言和地区点击下一步
   
   这里稍等片刻
   

2. 输入产品密钥，当然你也可以选择下方的我没有产品密钥

W269N-WFGWX-YVC9B-4J6C9-T83GX

这里这个是专业版的产品密钥，如果你需要其他版本的请自行百度

如果这里你选择我没有产品密钥会显示另外一个让你选择题系统版本的页面你选择你想要的系统即可

3. 接受许可条款
   

4. 选择自定义安装
   

5. 选择相应的磁盘然后点击下方的新建，强烈建议吧系统安装在SSD上（如果有）
   

然后它会提示需要创建其他分区我们点击确定

创建完成后应该是这样子的，因为我这里的虚拟机只分配了一个虚拟盘我就不分区了全部做系统盘你们在实体机上安装的时候可以自行分配

6. 选择下一步进行安装，等待安装完成即可。

7. 安装完成后会自动进行重启，这个时候你就可以拔出U盘，等待开机。

8. 当你看到这个熟悉的画面即代表系统已经安装成功了。

<完>

补充：Windows11的安装大同小异

前言

QoS（Quality of Service）是服务质量的简称。对于网络业务来说，服务质量包括哪些方面呢？从传统意义上来讲，无非就是传输的带宽、传送的时延、数据的丢包率等，而提高服务质量无非也就是保证传输的带宽，降低传送的时延，降低数据的丢包率以及时延抖动等。广义上讲，服务质量涉及网络应用的方方面面，只要是对网络应用有利的措施，其实都是在提高服务质量。因此，从这个意义上来说，防火墙、策略路由、快速转发等也都是提高网络业务服务质量的措施之一。

服务质量相对网络业务而言，在保证某类业务服务质量的同时，可能就是在损害其它业务的服务质量。因为网络资源总是有限的，只要存在抢夺网络资源的情况，就会出现服务质量的要求。比如，网络总带宽为100Mbps，而BT下载占用了90Mbps，其他业务就只能占用剩下的10Mbps。而如果限制BT下载占用的最大带宽为50Mbps，也就提高了其他业务的服务质量，使其他业务能够占用最少50Mbps的带宽，但这是在损害BT业务的服务质量为前提的。

QoS模型

网络中的通信都是由各种应用流组成的，这些应用对网络服务和性能的要求各不相同，比如FTP下载业务希望能获取尽量多的带宽，而VoIP语音业务则希望能保证尽量少的延迟和抖动等。但是所有这些应用的特殊要求又取决于网络所能提供的QoS能力，根据网络对应用的控制能力的不同，可以把网络的QoS能力分为三种模型：

2.1 Best Effort模型
Best Effort（尽力而为）模型是最简单的服务模型，应用程序可以在任何时候，发出任意数量的报文，网络尽最大的可能性来发送报文，对带宽、时延、抖动和可靠性等不提供任何保证。

Best Effort是Internet的缺省服务模型，通过FIFO（First In First Out，先进先出）队列来实现。

尽力而为的服务实质上并不属于QoS的范畴，因为在转发尽力而为的通信时，并没有提供任何服务或转发保证。

DiffServ模型

DiffServ（Differentiated Service，区分服务）模型由RFC2475定义，在区分服务中，根据服务要求对不同业务的数据进行分类，对报文按类进行优先级标记，然后有差别地提供服务。

区分服务一般用来为一些重要的应用提供端到端的QoS，它通过下列技术来实现：

1）流量标记与控制技术：它根据报文的CoS（Class of Service，服务等级）域、ToS域（对于IP报文是指IP优先级或者DSCP）、IP报文的五元组（协议、源地址、目的地址、源端口号、目的端口号）等信息进行报文分类，完成报文的标记和流量监管。目前实现流量监管技术多采用令牌桶机制。

2）拥塞管理与拥塞避免技术：WRED、PQ、CQ、WFQ、CBQ等队列技术对拥塞的报文进行缓存和调度，实现拥塞管理与拥塞避免。

上述这些技术的主要实现原理将在下文的QoS基本原理中进行重点介绍。

IntServ模型

IntServ（Integrated Service，综合服务）模型由RFC1633定义，在这种模型中，节点在发送报文前，需要向网络申请资源预留，确保网络能够满足数据流的特定服务要求。

IntServ可以提供保证服务和负载控制服务两种服务，保证服务提供保证的延迟和带宽来满足应用程序的要求；负载控制服务保证即使在网络过载的情况下，也能对报文提供与网络未过载时类似的服务。

在IntServ模型中，网络资源的申请是通过信令来完成的，应用程序首先通知网络它自己的流量参数和需要的特定服务质量请求，包括带宽、时延等，应用程序一般在收到网络的确认信息，即确认网络已经为这个应用程序的报文预留了资源后，才开始发送报文。同时应用程序发出的报文应该控制在流量参数描述的范围以内。负责完成保证服务的信令为RSVP（Resource Reservation Protocol，资源预留协议），它通知网络设备应用程序的QoS需求。RSVP是在应用程序开始发送报文之前来为该应用申请网络资源的，所以是带外信令。

保证服务要求为单个流预先保留所有连接路径上的网络资源，而当前在Internet主干网络上有着成千上万条应用流，保证服务如果要为每一条流提供QoS服务就变得不可想象了。因此，IntServ模型很难独立应用于大规模的网络，目前主要与MPLS TE（Traffic Engineering，流量工程）结合使用。

QoS基本原理

流量分类与标记

流量分类，就是将流量划分为多个优先级或多个服务类，如使用以太网帧中802.1Q头保留的User Priority(用户优先级)字段标记服务级别，可以将以太网帧最多分成23 = 8类；使用IP报文头的ToS（Type of service，服务类型）字段的前三位（即IP优先级）来标记报文，可以将报文最多分成23 = 8类；使用DSCP（Differentiated Services Codepoint，区分服务编码点，ToS域的前6位），则最多可分成26 = 64类。在报文分类后，就可以将其它的QoS特性应用到不同的分类，实现基于类的拥塞管理、流量整形等。

对于MPLS网络报文，则一般是根据MPLS报文中的EXP域进行处理。EXP域包括3位，虽然RFC 3032把它叫做实验域，但它通常作为MPLS报文的CoS域，与IP网络的ToS或DSCP域等效。

对于流量的分类，上面提到的关于以太网帧的Cos域、IP报文的ToS域等与MPLS报文的EXP域等仅是分类的一种情况，其实几乎可以对报文的任何信息段进行分类，比如也可以根据源IP地址、目的IP地址、源端口号、目的端口号、协议ID等进行流量的分类。

虽然流量分类几乎可以根据报文的任何字段进行，但是流量分类标记则一般只对802.1Q 以太网帧的CoS域、IP报文的ToS域、MPLS报文的EXP域进行标记。流量的标记主要的目的就是让其他处理此报文的应用系统或设备知道该报文的类别，并根据这种类别对报文进行一些事先约定了的处理。

例如，在网络的边界做如下分类和标记：

1. 所有VoIP数据报文聚合为EF业务类，将报文的IP优先级标记为5，或者将DSCP值标记为EF；

2. 所有VoIP控制报文聚合AF业务类，将报文的IP优先级标记为4，或者将DSCP值标记为AF31。

当报文在网络边界被标记分类之后，在网络的中间节点，就可以根据标记，对不同类别的流量给予差别服务了。例如：对上述例子中的EF类业务保证时延和减少抖动，同时进行流量监管；对AF业务类在网络拥塞时仍然保证一定的带宽，等等。

拥塞管理技术原理

拥塞管理基本概念

在计算机数据通信中，通信信道是被多个计算机共享的，并且，广域网的带宽通常要比局域网的带宽小，这样，当一个局域网的计算机向另一个局域网的计算机发送数据时，由于广域网的带宽小于局域网的带宽，数据将不可能按局域网发送的速度在广域网上传输。此时，处在局域网和广域网之间的路由器将不能发送一些报文，即网络发生了拥塞。

如下图所示，当公司分支1向公司总部以100M的速度发送数据时，将会使Router2的串口S0/1发生拥塞。

拥塞管理是指网络在发生拥塞时，如何进行管理和控制。处理的方法是使用队列技术。将所有要从一个接口发出的报文进入多个队列，按照各个队列的优先级进行处理。不同的队列算法用来解决不同的问题，并产生不同的效果。常用的队列技术有FIFO、PQ、CQ、WFQ、CBWFQ等，下文逐一介绍这些常用队列技术的基本原理。

FIFO队列原理简述

FIFO（First In First Out，先进先出）队列示意图如下所示：

FIFO队列不对报文进行分类，当报文进入接口的速度大于接口能发送的速度时，FIFO按报文到达接口的先后顺序让报文进入队列，同时，FIFO在队列的出口让报文按进队的顺序出队，先进的报文将先出队，后进的报文将后出队。

FIFO队列具有处理简单，开销小的优点。但FIFO不区分报文类型，采用尽力而为的转发模式，使对时间敏感的实时应用（如VOIP）的延迟得不到保证，关键业务的带宽也不能得到保证。

PQ原理简述

PQ（Priority Queuing，优先队列）示意图如下所示：

PQ队列是针对关键业务应用设计的。关键业务有一个重要特点，需要在拥塞发生时要求优先获得服务以减少响应的延迟。PQ可以根据网络协议（如IP、IPX）、数据流入接口、报文长短、IP报文的ToS、五元组（协议ID、源IP地址、目的IP地址、源端口号、目的端口号）等条件进行分类，对于MPLS网络，则根据MPLS报文EXP域值进行分类。最终将所有报文分成最多4类，分别属于PQ的4个队列中的一个，然后，按报文所属类别将报文送入相应的队列。

PQ的4个队列分别为高优先队列、中优先队列、正常优先队列和低优先队列，它们的优先级依次降低。在报文出队的时候，PQ首先让高优先队列中的报文出队并发送，直到高优先队列中的报文发送完，然后发送中优先队列中的报文，同样，直到发送完，然后是正常优先队列和低优先队列。这样，分类时属于较高优先级队列的报文将会得到优先发送，而较低优先级的报文将会在发生拥塞时被较高优先级的报文抢占。这样会使得实时业务（如VoIP）的报文能够得到优先处理，非实时业务（如E-Mail）的报文在网络处理完关键业务后的空闲间隙得到处理，既保证了实时业务的优先，又充分利用了网络资源。

PQ的缺点是，当较高优先级队列中总有报文存在时，则低优先级队列中的报文将一直得不到服务，出现队列“饿死”现象。

CQ原理简述

CQ（Custom Queuing，定制队列）示意图如下所示：

CQ的分类方法和PQ基本相同，不同的是它最终将所有报文分成最多至17类，每类报文对应CQ中的一个队列，接口拥塞时，报文按匹配规则被送入对应的队列；如果报文不匹配任何规则，则被送入缺省队列（缺省队列默认为1，可配置修改缺省队列）。

CQ的17个队列中，0号队列是优先队列，路由器总是先把0号队列中的报文发送完，然后才处理1到16号队列中的报文，所以0号队列一般作为系统队列，把实时性要求高的交互式协议报文放到0号队列。1到16号队列调度采用轮询方式，按照用户预先配置的额度依次从1到16号用户队列中取出一定数量的报文发送。如果轮询到某队列时该队列恰好为空，则立即转而轮询下一个队列。

CQ把报文分类，然后按类别将报文分配到CQ的一个队列中去，而对每个队列，又可以规定队列中的报文所占接口带宽的比例，这样，就可以让不同业务的报文获得合理的带宽，从而既保证关键业务能获得较多的带宽，又不至于使非关键业务得不到带宽。但由于采用轮询调度各个队列，CQ无法保证任何数据流的延迟。

WFQ原理简述

WFQ（Weighted Fair Queuing，加权公平队列）示意图如下所示：

WFQ对报文按流特征进行分类，对于IP网络，相同源IP地址、目的IP地址、源端口号、目的端口号、协议号、ToS的报文属于同一个流，而对于MPLS网络，具有相同的标签和EXP域值的报文属于同一个流。每一个流被分配到一个队列，该过程称为散列，采用HASH算法来自动完成，这种方式会尽量将不同特征的流分入不同的队列中。每个队列类别可以看作是一类流，其报文进入WFQ中的同一个队列。WFQ允许的队列数目是有限的，用户可以根据需要配置该值。

在出队的时候，WFQ按流的优先级（precedence）来分配每个流应占有出口的带宽。优先级的数值越小，所得的带宽越少。优先级的数值越大，所得的带宽越多。这样就保证了相同优先级业务之间的公平，体现了不同优先级业务之间的权值。

WFQ优点在于配置简单，有利于小包的转发，每条流都可以获得公平调度，同时照顾高优先级报文的利益。但由于流是自动分类，无法手工干预，故缺乏一定的灵活性，且受资源限制，当多个流进入同一个队列时无法提供精确服务，无法保证每个流获得的实际资源量。WFQ均衡各个流的延迟与抖动，同样也不适合延迟敏感的业务应用。

CBQ原理简述

CBQ（Class Based Queuing，基于类的队列）示意图如下所示：

CBQ首先根据IP优先级或者DSCP、输入接口、IP报文的五元组等规则来对报文进行分类；对于MPLS网络的LSR，主要是根据EXP域值进行分类。然后让不同类别的报文进入不同的队列。对于不匹配任何类别的报文，报文被送入系统定义的缺省类。

CBQ包括一个低时延队列LLQ（Low Latency Queuing，低时延队列），用来支撑EF（Expedited Forwarding，快速转发）类业务，被绝对优先发送，保证时延。进入EF的报文在接口没有发生拥塞的时候（此时所有队列中都没有报文），所有属于EF的报文都可以被发送。在接口发生拥塞的时候（队列中有报文时），进入EF的报文被限速，超出规定流量的报文将被丢弃。

另外有64个BQ队列（Bandwidth Queuing，带宽保证队列），用来支撑AF（Assured Forwarding，确保转发）类业务，可以保证每一个队列的带宽及可控的时延。系统调度报文出队列的时候，按用户为各类报文设定的带宽将报文出队发送。这种队列技术应用了先进的队列调度算法，可以实现各个类的队列的公平调度。当接口中某些类别的队列没有报文时，BQ队列的报文还可以公平地得到空闲的带宽，和时分复用系统相比，大大提高了线路的利用率。同时，在接口拥塞的时候，仍然能保证各类报文得到用户设定的最小带宽。

最后还有一个WFQ队列，对应BE（Best Effort，尽力传送）业务，使用接口剩余带宽进行发送。

CBQ可根据报文的输入接口、满足ACL情况、IP Precedence、DSCP、EXP、Label等规则对报文进行分类、进入相应队列。对于进入EF和AF的报文，要进行测量；考虑到链路层控制报文的发送、链路层封装开销及物理层开销（如ATM信元头），建议EF与AF占用接口的总带宽不要超过接口带宽的75%。

CBQ可为不同的业务定义不同的调度策略（如带宽、时延等），由于涉及到复杂的流分类，对于高速接口（GE以上）启用CBQ特性系统资源存在一定的开销。

RTP原理简述

RTP优先队列(Real Time Protocol Priority Queuing) 示意图如下所示：

RTP优先队列是一种保证实时业务（包括语音与视频业务）服务质量的简单队列技术。其原理就是将承载语音或视频的RTP报文送入高优先级队列，使其得到优先发送，保证时延和抖动降低为最低限度，从而保证了语音或视频这种对时延敏感业务的服务质量。

RTP优先队列将RTP报文送入一个具有较高优先级的队列，RTP报文是端口号在一定范围内为偶数的UDP报文，端口号的范围可以配置，一般为16384~32767。RTP优先队列可以同前面所述的任何一种队列（包括FIFO、PQ、CQ、WFQ与CBQ）结合使用，它的优先级是最高的。由于CBQ中的EF完全可以解决实时业务，所以不推荐将RTP优先队列与CBQ结合应用。

由于对进入RTP优先队列的报文进行了限速，超出规定流量的报文将被丢弃，这样在接口拥塞的情况下，可以保证属于RTP优先队列的报文不会占用超出规定的带宽，保护了其他报文的应得带宽，解决了PQ的高优先级队列的流量可能“饿死”低优先级流量的问题。

拥塞避免原理

受限于设备的内存资源，按照传统的处理方法，当队列的长度达到规定的最大长度时，所有到来的报文都被丢弃。对于TCP报文，如果大量的报文被丢弃，将造成TCP超时，从而引发TCP的慢启动和拥塞避免机制，使TCP减少报文的发送。当队列同时丢弃多个TCP连接的报文时，将造成多个TCP连接同时进入慢启动和拥塞避免，称之为：TCP全局同步。这样多个TCP连接发向队列的报文将同时减少，使得发向队列的报文的量不及线路发送的速度，减少了线路带宽的利用。并且，发向队列的报文的流量总是忽大忽小，使线路的上的流量总在极少和饱满之间波动。

为了避免这种情况的发生，队列可以采用加权随机早期检测WRED（Weighted Random Early Detection）的报文丢弃策略（WRED与RED的区别在于前者引入IP优先权，DSCP值，和MPLS EXP来区别丢弃策略）。采用WRED时，用户可以设定队列的阈值（threshold）。当队列的长度小于低阈值时，不丢弃报文；当队列的长度在低阈值和高阈值之间时，WRED开始随机丢弃报文（队列的长度越长，丢弃的概率越高）；当队列的长度大于高阈值时，丢弃所有的报文。

WRED和队列机制的关系如下图所示：

流量监管原理

流量监管（Commit Access Rate，简称CAR）的典型作用是限制进入某一网络的某一连接的流量与突发。在报文满足一定的条件时，如某个连接的报文流量过大，流量监管就可以对该报文采取不同的处理动作，例如丢弃报文，或重新设置报文的优先级等。通常的用法是使用CAR来限制某类报文的流量，例如限制HTTP报文不能占用超过50%的网络带宽。

CAR利用令牌桶（Token Bucket，简称TB）进行流量控制。下图所示为利用CAR进行流量控制的基本处理过程：

首先，根据预先设置的匹配规则来对报文进行分类，如果是没有规定流量特性的报文，就直接继续发送，并不需要经过令牌桶的处理；如果是需要进行流量控制的报文，则会进入令牌桶中进行处理。如果令牌桶中有足够的令牌可以用来发送报文，则允许报文通过，报文可以被继续发送下去。如果令牌桶中的令牌不满足报文的发送条件，则报文被丢弃。这样，就可以对某类报文的流量进行控制。

在实际应用中，CAR不仅可以用来进行流量控制，还可以进行报文的标记（mark）或重新标记（re-mark）。具体来讲就是CAR可以设置IP报文的优先级或修改IP报文的优先级，达到标记报文的目的。

流量整型原理

通用流量整形（Generic Traffic Shaping，简称GTS）可以对不规则或不符合预定流量特性的流量进行整形，以利于网络上下游之间的带宽匹配。

GTS与CAR一样，均采用了令牌桶技术来控制流量。GTS与CAR的主要区别在于：利用CAR在接口的出、入方向进行报文的流量控制，对不符合流量特性的报文进行丢弃；而GTS只在接口的出方向对于不符合流量特性的报文进行缓冲，减少了报文的丢弃，同时满足报文的流量特性，但增加了报文的延迟。

GTS的基本处理过程如下图所示，其中用于缓存报文的队列称为GTS队列。

物理接口总速率限制原理

利用物理接口总速率限制（Line Rate，简称LR）可以在一个物理接口上，限制接口发送报文（包括紧急报文）的总速率。

LR的处理过程仍然采用令牌桶进行流量控制。如果用户在路由器的某个接口上配置了LR，规定了流量特性，则所有经由该接口发送的报文首先要经过LR的令牌桶进行处理。如果令牌桶中有足够的令牌可以用来发送报文，则报文可以发送。如果令牌桶中的令牌不满足报文的发送条件，则报文入QoS队列进行拥塞管理。这样，就可以对通过该物理接口的报文流量进行控制。

LR的基本处理过程如下图所示：

其他提高QoS的技术

链路效率机制

链路效率机制，用于改善链路的性能，间接提高网络的QoS，如降低链路发包的时延（针对特定业务）、调整有效带宽。链路效率机制有很多种，下面介绍两种比较典型的链路效率机制及其基本原理。

链路分片与交叉（Link Fragment & Interleave，LFI）

对于低速链路，即使为语音等实时业务报文配置了高优先级队列（如RTP优先队列或LLQ），也不能够保证其时延与抖动，原因在于接口在发送其他数据报文的瞬间，语音业务报文只能等待，而对于低速接口发送较大的数据报文要花费相当长的时间。采用LFI以后，数据报文（非RTP实时队列和LLQ中的报文）在发送前被分片、逐一发送，而此时如果有语音报文到达则被优先发送，从而保证了语音等实时业务的时延与抖动。LFI主要用于低速链路。

链路效率机制的工作原理图如下所示：

如上图所示，应用LFI技术，在大报文出队的时候，可以将其分为定制长度的小片报文，这就使RTP优先队列或LLQ中的报文不必等到大片报文发完后再得到调度，它等候的时间只是其中小片报文的发送时间，这样就很大程度的降低了低速链路因为发送大片报文造成的时延。

RTP报文头压缩（RTP Header Compression，CRTP）

CRTP用于RTP（Real-time Transport Protocol）协议，对IP头、UDP头和RTP头进行压缩，通常在低速链路上使用。可将40字节的IP/UDP/RTP头压缩到2~4个字节（不使用UDP校验和可到2字节），提高链路带宽的利用率。CRTP主要得益于同一会话的语音分组头和语音分组头之间的差别往往是不变的，因此只需传递增量。

RTP协议用于在IP网络上承载语音、视频等实时多媒体业务。RTP报文包括头部分和数据部分，RTP的头部分包括：12字节的RTP头，加上20字节的IP头和8字节的UDP头，就是40字节的IP/UDP/RTP头；RTP数据部分典型载荷是20字节到160字节。为了避免不必要的带宽消耗，可以使用CRTP特性对报文头进行压缩。CRTP可以将IP/UDP/RTP头从40字节压缩到2～4字节，对于40字节的载荷，头压缩到4字节，压缩比为（40+40）/（40+4），约为1.82，可见效果是相当可观的，可以有效的减少链路带宽的消耗，尤其是低速链路。

RTP报文头压缩的处理过程如下图所示：

链路层QoS技术

链路层QoS技术主要针对ATM（Asynchronous Transfer Mode，异步传输模式）、帧中继等链路层协议支持QoS。ATM作为一种面向连接的技术，提供对QoS最强有力的支持，而且可以基于每个连接提供特定的QoS保证；帧中继网络确保连接的CIR（Committed Information Rate，承诺信息速率）最小，即在网络拥塞时，传输速度不能小于这个值。

ATM QoS

ATM是异步传输模式（Asynchronous Transfer Mode）的简称，以信元为基本单位进行信息传输、复接和交换。ATM信元具有53字节的固定长度，其中5个字节构成信元头部，主要用来标识虚连接，另外也完成了一些功能有限的流量控制，拥塞控制，差错控制等功能，其余48个字节是有效载荷。ATM是面向连接的交换，其连接是逻辑连接，即虚电路。每条虚电路（Virtual Circuit，VC）用虚路径标识符（Virtual Path Identifier，VPI）和虚通道标识符（Virtual Channel Identifier，VCI）来标识。一个VPI/VCI值对只具有本地意义，不具有全局有效性。它在ATM节点上被翻译。当一个连接被释放时，与此相关的VPI/VCI值对也被释放，它被放回资源表，供其它连接使用。

ATM中每一条VC都有一定的QoS保障，这是由ATM的连接管理来实现的。当用户与网络或网络与网络建立一个连接的时候，双方就确定了一份通信契约，契约中包括流量参数和QoS参数两部分。此通信契约为双方所共识，双方必须遵守。流量参数包括峰值信元速率（PCR，Peak Cell Rate）、持续信元速率（SCR，Sustained Cell Rate）、最小信元速率（MCR，Minimum Cell Rate）以及最大突发量（MBS，Maximum Burst Size），它们描述业务本身的流量特性，又称为源流量参数。QoS参数主要包括最大信元传递时延（MCTD，MeanCell Transfer Delay）、信元抖动容限（CDVT，CellDelayVariationTolerance）和信元丢失率（CLR，Cell Loss Ratio）， MCTD是信元从一个端点到另一个端点所需要的时间， CDVT是信元间隔的上限， CLR是可以接受的因网络拥塞而导致信元丢失比例。

ATM端系统负责确保传输的流量符合QoS合同。ATM端系统通过缓冲数据来对流量进行整形，并按约定的QoS参数传输通信。ATM交换机控制每个用户的通信指标，并将其与QoS合同进行比较。对于超过了QoS合同的通信，ATM节点可以设置信元的CLP（Cell Loss Priority，信元丢弃优先级）位。在网络拥塞时，CLP置位的信元被丢弃的可能性更大。

ATM网络拥塞管理的基本思想在于：引入预防性控制措施，不再是出现拥塞之后再采取措施来消除拥塞，而是通过精心管理网络资源来避免拥塞的出现。

FR QoS

FR（Frame Relay，帧中继）是一种统计复用的协议，它能够在单一物理传输线路上提供多条虚电路。每条虚电路用DLCI（Data Link Connection Identifier，数据链路连接标识）来标识。每条虚电路通过LMI（Local Management Interface，本地管理接口）协议检测和维护虚电路的状态。

帧中继采用VC（Virtual Circuit）虚电路技术，即帧中继传送数据使用的传输链路是逻辑连接，而不是物理连接。虚电路是面向连接的，可以保证用户帧按顺序传送至目的地。根据虚电路建立方式的不同，将帧中继虚电路分为两种类型：永久虚电路（PVC，Permanent Virtual Circuit）和交换虚电路（SVC，Switched Virtual Circuit）。PVC是手工设置产生的虚电路，而SVC是通过协议协商自动创建和删除的虚电路。

帧中继报头中的3个位提供了帧中继网络中的拥塞控制机制，这3个位分别叫做向前显式拥塞通知（FECN，Forward Explicit Congestion Notification）位、向后显式拥塞通知（BECN，Backward Explicit Congestion Notification）位和丢弃合格（DE，Discard Eligible）位。可以通过帧中继交换机将FECN位置1来告知诸如路由器等目标数据终端设备（DTE，Data Terminal Equipment），在帧从源传送到目的地的方向发生了拥塞。帧中继交换机将BECN位置1则告知目标路由器，在帧从源传送到目的地的反方向上发生了拥塞。DE位由路由器或其他DTE设备设置，指出被标记的帧没有传输的其他帧那么重要，它在帧中继网络中提供了一种基本的优先级机制，如果发生拥塞时，DE位置位的帧会被优先丢弃。

帧中继流量整形（FRTS，Frame Relay Traffic Shaping）对从帧中继VC输出的通信进行整形，使之与配置速率一致，它将超出平均速率的分组放到缓冲区来使突发通信变得平滑。根据配置的排队机制，当有足够的可用资源时，这些缓冲的分组出队并等候被传输。排队算法是基于单个VC配置的，它只能针对接口的出站通信进行设置。FRTS可对每个VC的流量进行整形，将其峰值速率整形为承诺信息速率（CIR，Committed Information Rate）或其他定义的值，如超额信息速率（EIR，Excess Information Rate）。自适应模式的FRTS还能够根据收到的网络BECN拥塞指示符降低帧中继VC的输出量，将PVC的输出流量整形为与网络的可用带宽一致。

<完>

ShadowSocks的介绍

ShadowSocks 是由@clowwindy所开发的一个开源网络代理工具。它是一个安全的 Socks5 代理。作用一个可穿透防火墙的快速代理 。

ShadowSocks 的原理

Shadowsocks是一种基于Socks5代理方式的加密传输协议，也可以指实现这个协议的各种传输包。shadowsocks分为服务器端和客户端，由本地计算机发出一个数据包给本地的shadowsocks服务器发送数据加密请求(这里的本地shadowsocks服务器指的是 SS Local 如你手机或电脑上安装的软件也可以是软路由等硬件)，因为本地服务器在本地不经过墙并且可以瞬间完成加密，然后 发送加密数据==>DNS解析==>通过骨干网到达国际出口 GFW因为探测不到有特别特征的流量，所以也放行到达你的远程中转服务器然后解密你的数据然后转发到Google；得到回应后数据发送回来经过远程中转服务器加密，加密数据经过GFW，因为探测不到特征明显的流量，同时也不是HTTP的明文数据，所以GFW无法嗅探到敏感词，那么只好放行，达到你的本地Shadowsocks服务器，经过解密数据包发送回你的本地计算机。

Shadowsocks的运行原理与其他代理工具基本相同，使用特定的中转服务器完成数据传输。

Shadowsocks特点

• Shadowsocks使用自行设计的协议进行加密通信。加密算法有AES、Blowfish、IDEA、RC4等，除创建TCP连接外无需握手，每次请求只转发一个连接，无需保持“一直连接”的状态，因此在移动设备上相对较为省电。
• 所有的流量都经过算法加密，允许自行选择算法。
• Shadowsocks通过异步I/O和事件驱动程序运行，响应速度快。
• 客户端覆盖多个主流操作系统和平台，包括Windows、OS X、Android、Linux和iOS系统和路由器（OpenWrt）等。

<完>

内容分发网络（英语：Content Delivery Network或Content Distribution Network，缩写：CDN）它是指一种透过互联网互相连接的电脑网络系统，利用最靠近每位用户的服务器，更快、更可靠地将音乐、图片、视频、应用程序及其他文件发送给用户，来提供高性能、可扩展性及低成本的网络内容传递给用户

优点

内容分发网络的总承载量可以比单一骨干最大的带宽还要大。这使得内容分发网络可以承载的用户数量比起传统单一服务器多。也就是说，若把有100Gbps处理能力的服务器放在只有10Gbps带宽的数据中心，则亦只能发挥出10Gbps的承载量。但如果放到十个有10Gbps的地点，整个系统的承载量就可以到10*10Gbps。

同时，将服务器放到不同地点，可以减少互连的流量，进而降低带宽成本。

对于TCP传输而言，TCP的速度（throughput）会受到延迟时间（latency）与数据包漏失率（packet loss）影响。为了改善这些负面因素，内容分发网络通常会指派较近、较顺畅的服务器节点将资料传输给用户。虽然距离并不是绝对因素，但这么做可以尽可能提高性能，用户将会觉得比较顺畅。这使得一些比较高带宽的应用（传输高清视频）更容易推动。

内容分发网络另外一个好处在于有异地备援。当某个服务器故障时，系统将会调用其他邻近地区的服务器服务，进而提供接近100%的可靠度。

除此之外，内容分发网络提供给服务提供者更多的控制权。提供服务的人可以针对客户、地区，或是其他因子调整。

技术

内容分发网络节点会在多个地点，多个不同的网络上摆放。这些节点之间会动态的互相传输内容，对用户的下载行为优化，并借此减少内容供应者所需要的带宽成本，改善用户的下载速度，提高系统的稳定性。

内容分发网络所需要的节点数量随着需求而不同，依照所需要服务的对象大小，有可能有数万台服务器。

服务器的运作方式一般是基于nginx的模式，也就是仅仅缓存网站的静态内容，不过，随着2017年世界各地CDN服务商纷纷推出HTTPS加速功能，运作方式也变得略有不同，变成了nginx+SNI（一个CDN节点上可以借此技术绑定N个域名），同时，BGP anycast技术也逐渐引入了CDN领域中。

P2P CDN

因部署或租用机房带来的多方面高昂成本和管理压力，学界和业界也研究了将P2P技术融入CDN部署和管理的技术，以降低运营成本和通信时延。中国大陆的迅雷、优酷、百度、阿里巴巴等公司就在2010年代多次尝试用户端运行的P2P众包类CDN服务、专用设备，模式为用户自愿以PC或专用设备利用闲置上行带宽充当CDN缓存节点，提供服务并赚取积分，而积分可兑换现金红包、特定商品或服务。

<完>

一、获取管理员权限

sudo -i

二、进入 usr 目录，使用 wget 下载JDK包

cd /usr && wget https://download.oracle.com/otn-pub/java/jdk/16.0.1+9/7147401fd7354114ac51ef3e1328291f/jdk-16.0.1_linux-x64_bin.tar.gz

注意：如果在使用的过程中报以下错误

-bash: wget: command not found

说明你还没安装 wget 我们安装一下即可

yum -y install wget

三、解压安装文件

下载完成之后你可以通过ls命令来查看下载的内容
通过使用ls命令查看到的我这里下载的包名称是 jdk-16.0.1_linux-x64_bin.tar.gz 如果你下载的不是这个名称请修改成你自己的。

tar -zxvf jdk-16.0.1_linux-x64_bin.tar.gz

解压完之后再次通过ls命令查看能看到一个jdk-16.0.1的文件夹。

四、配置java的环境变量

编辑profile文件,把命令保存到文件中

vim /etc/profile

在配置文件的最后加入以下三行：

export JAVA_HOME=/usr/jdk-16.0.1
export CLASSPATH=.:$JAVA_HOME/lib
export PATH=$PATH:$JAVA_HOME/bin

保存退出。

五、更新配置使配置生效。

source /etc/profile

六，检查java安装的效果

java -version

返回以下内容，即代表安装成功。

java version "16.0.1" 2021-04-20
Java(TM) SE Runtime Environment (build 16.0.1+9-24)
Java HotSpot(TM) 64-Bit Server VM (build 16.0.1+9-24, mixed mode, sharing)

<完>

今天在安装screen的时候出现以下错误

[root@server07 ~]# yum -y install screen
No match for argument: screen
Error: Unable to find a match

这个问题应该是没有配置 yum 源，所以解决办法就是：安装 EPEL 的源即可解决

yum install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm

<完>

需要材料：
1.公网服务器一台
2.SSH软件
3.基础Liunx知识
国内服务器我推荐使用 阿里云，腾讯云，华为云等大厂的云服务提供商如果你还想知道其他的云服务提供商可以百度 VPS 云服务器 等关键字，

注1: 我没有邀请码或推广链接我不通过这种方式获利。请自行决定使用谁家的服务器。

注2：以下的命令基于 CentOS 7 的系统,请在选择操作系统的时候选择 CentOS 7

1. 使用 SSH 软件连接上服务器

2. 获取管理员权限

sudo -i

3. 升级系统

yum update

如有询问你是否允许的输入 y 允许即可(如下)

4. 安装Java JDK 11及其他所需软件（同理如有询问你是否允许安装输入 y 后按回车允许）

yum install java-11-openjdk -y
yum install wget screen git

​ 4_1. 安装完Java之后还需要验证Java是否可用

java -version

如果能如下正常弹出版本号即代表安装成功

5. 安装完之后我们创建并进去一个文件夹

mkdir mc && cd mc

mkdir 为创建文件夹

cd 为进入文件夹

这里 mc 为文件夹的名称你可以修改成你自己想要的名称，我这里演示就叫 mc 了

当你看到你的文件夹名称的时候说明你现在已经进去了该文件夹内

6. 下载官方的 jar 文件 这里我以官方最新的包为例，

wget https://launcher.mojang.com/v1/objects/1b557e7b033b583cd9f66746b7a9ab1ec1673ced/server.jar

下载其他版本

wget https://s3.amazonaws.com/Minecraft.Download/versions/版本号/minecraft_server.版本号.jar

如我需要下载1.12.2版本的命令为（其他同理）

wget https://s3.amazonaws.com/Minecraft.Download/versions/1.12.2/minecraft_server.1.12.2.jar

下载完成之后我们输入 ls 查看文件夹里的内容会发现多了一个 server.jar 的文件（如你下载的是1.12.2的版本那么你ls 出来的应该是 minecraft_server.1.12.2.jar )

7. 安装“我的世界”服务端

下载好了服务端的 .jar 文件之后，你就需要先运行一下，它会生成一些文件，包括一个 eula.txt 许可文件。第一次运行的时候，它会返回一个错误并退出。这是正常的。使用下面的命令运行它：

java -Xms2048M -Xmx3472M -jar server.jar nogui

-Xms2048M 是你的服务端能使用的最小的内存

-Xmx3472M 是最大的内存。调整 基于你服务器的硬件资源。如果你的服务器上有 4GB 内存，并且不用服务器来干其他事情的话可以就这样留着不动。

server.jar 是你的服务端文件，如果你刚才

在这条命令结束并返回一个错误之后，将会生成一个新的 eula.txt 文件。你需要同意那个文件里的协议。你可以通过下面这条命令将 eula=true 添加到文件中：

sed -i.orig 's/eula=false/eula=true/g' eula.txt

你现在可以通过和上面一样的命令来开启服务端并进入“我的世界”服务端控制台了：

java -Xms2048M -Xmx3472M -jar server.jar nogui

如果你只是测试或暂时需要的话，到这里就可以停了。如果你在登录服务器时有问题的话，你就需要配置你的防火墙。

第一次成功启动服务端时会花费一点时间来生成。

8. 使用脚本启动“我的世界”服务端，让服务端长期运行并在启动时开启

方便起见，我们将创建一个自动启动服务端的 bash 脚本。

首先，使用 vim 创建一个 bash 脚本：

vim start.sh

start 为文件名称你可以修改成你自己的

这将会打开一个新的（空白）文件。我们按下键盘上的 i 当你看到左下角 / 右下角出现了 -- INSERT -- 字样的时候，粘贴以下内容：(每个ssh软件的粘贴快捷键都不太一样，但一般你都可以通过鼠标右键看到有粘贴的按钮)

#!/bin/bash
cd /root/mc/ && java -Xms2048M -Xmx3472M -jar server.jar nogui

输入完成之后先按键盘 左上角 ESC 键 左下角 / 右下角的 -- INSERT -- 字样消失 代表退出编辑模式

然后接着输入 :wq! 强制保存并退出

如果你在编辑的时候出错了也不用怕输入:q! 强制退出即可 。! 就是就是强制的意思 如果你不想使用强制退出那你不输入! 即可。

然后，你就可以通过下面的命令随时运行服务端了：

./start.sh

start 为你刚才创建的文件名，如果你前面修改了那你这里也需要修改成相同的

如果出现 -bash: ./start.sh: Permission denied 的报错不用担心，是因为没有权限，输入命令给它权限然后再次运行即可

chmod u+x start.sh

当你看到 For help, type "help" 时代表服务器已经运行成功这时你就可以通过IP连接到这台服务器上了

但是，如果/当你登出 SSH 会话的话，服务端就会关闭。要想让服务端不登录也持续运行的话，你可以使用 screen 会话。screen 会话会一直运行，直到实际的服务器被关闭或重启。现在我们按下 CTRL+C 键停止当前任务，然后输入 screen 然后回车

一旦你进入了 screen 会话（看起来就像是你新建了一个 SSH 会话），你就可以使用先前创建的 bash 脚本来启动服务端：

要退出 screen 会话的话，你应该按 CTRL+A-D。即使你离开 screen 会话（断开的），服务端也会继续运行。你现在可以安全的登出服务器了，你创建的“我的世界”服务端将会继续运行。

9. 服务器内放通端口

运行命令：

firewall-cmd --get-active-zones

执行如下命令放通所需端口：

firewall-cmd --zone=public --add-port=25565/tcp --permanent

当你看到 Warning: ALREADY_ENABLED: 25565:tcp 说明25565端口放通成功

重启防火墙

firewall-cmd --reload

查看放通的端口

firewall-cmd --zone=public --list-ports

当你看到 25565/tcp 说明TCP协议的25565端口放通成功

你应该根据你的使用情况开放或拒绝其他规则。如果你不用服务器负载网站的话，就应该拒绝 80 和 443 端口。谷歌一下防火墙指南，你会得到建议的。设置防火墙的时候小心一些，如果你屏蔽了 SSH(22) 端口的话你会把自己锁在服务器外面。你就永远都连不上服务器了 这个时候你只能去重置系统了
大多数服务器提供商还有一个VPS防火墙你还需要在你的提供商的控制台中放通相应协议的相应端口

10.我该如何在服务端上安装 mod 和插件？

我们的文章意图作一篇入门指南，你应该查看 我的世界维基，或者谷歌一下来获取更多信息。网上有很多教程。我后面也会写出相应的教程。

服务器的部署已经完成，下面是面板的使用。

对于新手我更加建议你使用[MCSM管理面板]

MCSM管理面板 Github 官方仓库：https://github.com/Suwings/MCSManager

Forge官网：https://files.minecraftforge.net

Minecraft官网：https://www.minecraft.net/zh-hans

其他版本官方包下载：https://s3.amazonaws.com/Minecraft.Download/versions/版本号/minecraft_server.版本号.jar

这是使用教程并没有面板的部署过程，官方的GitHub仓库里已有详细的安装教程，如你需要请在上面的链接查看官方的教程

开始部署

1. 到 Forge 官网下载你所需版本的包 我这里以1.16.5 版本做演示，其他版本大同小异。

   1.1. 选择你需要的Forge安装版本 Download Latest 为最新版， Download Recommended 为稳定版，我建议下载稳定版的。

   1.2. 在 Installer(安装程序) 处 鼠标右键 选择 复制链接地址

   1.3. 这个时候你会得到一个类似这样子的地址

   https://adfoc.us/serve/sitelinks/?id=271228&url=https://maven.minecraftforge.net/net/minecraftforge/forge/1.16.5-36.1.0/forge-1.16.5-36.1.0-installer.jar
   

   我们需要吧前面的 https://adfoc.us/serve/sitelinks/?id=271228&url= 去掉得到这样子的一个地址

   https://maven.minecraftforge.net/net/minecraftforge/forge/1.16.5-36.1.0/forge-1.16.5-36.1.0-installer.jar
   

   删除前面那一段的原因是，这是个非营利性网站该站收入大部分来源于广告收入，删掉的那个正是广告的域名。= 的后面才是下载的地址，我们把真正的地址复制出来 然后粘贴到浏览器上并回车下载

2. 下载完成后登录MCSM管理面板

3. 进入 服务器管理 标签点击 创建新实例应用 选择 引导创建

4. 名称自定义 (禁止使用中文) ，建议使用new _ ID _ 版本号 或 new _ ID _ 版本号 _ 游戏名称 的命名规范 用于分辨服务器。项目位置自动即可 选择 下一步

ID 为你登录面板的用户名 。
版本号 请以全数字的方式如 1.16.5 就重命为 1165 。

5. 上传刚刚你从 Forge 官网下载的安装程序，待提示 上传成功 并显示 启动程序端 的文件名后点击下一步

6. 输入 运行内存 我这里演示就输入了一个较大的，服务器资源 最大内存 为 4G 除去面板及Java所需的内存外 可用最大内存 为 3G ，建议初始内存堆为1G，最大内存堆为 2G，确认无误后进行创建 ![9]

开始安装库 及 运行

1. 进入 服务器管理 标签点击 参数 选择 自定义命令 输入下方启动命令并保存

   java -jar <文件名.jar> --installServer
   

2. 点击 终端 > 开启 这时开始下载该版本所需的运行库 libraries 文件夹，待它自动停止之后点击 关闭窗口

3. 点击 管理 > 文件在线管理

4. 删除掉安装程序并复制下Forge程序名称跟官方程序的名称

5. 回到 参数 页面，删除自定义命令，并修改服务端名称(第一次先修改成Forge程序名称)，保存

6. 点击 终端 > 开启 这时开始运行服务端它会自动创建 mods defaultconfigs logs world 等文件夹之后它会自动关闭，这时候我们再回到参数里在服务端文件名里修改成功官方的程序，保存然后再次去启动。

7. 待出现 help 字样就可点击 关闭窗口 去打开游戏尝试连接服务器了（注意是关闭窗口 ，而不是关闭）

安装MOD

1. 选择你的服务器然后 管理 > 文件在线管理 找到 mods 文件夹 然后吧你的mod文件上传上去。

2. 重启服务器

修改 Server.properties 配置文件

1. 选择你的服务器然后 管理 > Server.properties 配置文件

这里面可以修改一些配置参数，如 PVP 人数上限 服务器端口 正版验证 等等

修改完成之后保存 重启服务器即可。

什么是BBR

BBR是Google 提出的一种新型拥塞控制算法，可以使Linux服务器显著地提高吞吐量和减少TCP连接的延迟。Google已经开源了该算法，并提交到了Linux内核，从4.9开始，Linux内核已经用上了该算法。

BBR解决了什么问题：

1. 在有一定丢包率的网络链路上充分利用带宽。非常适合高延迟，高带宽的网络链路。

2. 降低网络链路上的buffer占用率，从而降低延迟。非常适合慢速接入网络的用户。

BBR加速安装教程如下。

前面说了Liunx内核从4.9开始已经内置了该算法。

一、升级内核

查看当前内核版本：

uname -r

假如现在得到如下结果：

3.10.0-514.10.2.el7.x86_64

说明当前内核版本低于 4.10，需要使用 ELRepo 源更新：

sudo rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
sudo rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-2.el7.elrepo.noarch.rpm
sudo yum --enablerepo=elrepo-kernel install kernel-ml -y

安装完成后，查看已安装的内核：

rpm -qa | grep kernel

得到结果如下：

kernel-3.10.0-123.el7.x86_64
kernel-headers-3.10.0-514.16.1.el7.x86_64
kernel-ml-4.11.0-1.el7.elrepo.x86_64
kernel-tools-3.10.0-514.16.1.el7.x86_64
kernel-3.10.0-514.16.1.el7.x86_64
kernel-tools-libs-3.10.0-514.16.1.el7.x86_64

在输出中看到 kernel-ml-4.11.0-1.el7.elrepo.x86_64 类似的内容，表示安装成功。

第二步，修改grub2引导

执行命令：

sudo egrep ^menuentry /etc/grub2.cfg | cut -f 2 -d \'

会得到如下结果：

CentOS Linux 7 Rescue a0cbf86a6ef1416a8812657bb4f2b860 (4.11.0-1.el7.elrepo.x86_64)
CentOS Linux (4.11.0-1.el7.elrepo.x86_64) 7 (Core)
CentOS Linux (3.10.0-514.16.1.el7.x86_64) 7 (Core)
CentOS Linux (3.10.0-123.el7.x86_64) 7 (Core)
CentOS Linux (0-rescue-2d3f9371c20d3e90a544ccc814d485e3) 7 (Core)

由于序号从0开始，设置默认启动项为1并重启系统：

sudo grub2-set-default 1
reboot

重启完成后，查看当前内核版本：

uname -r

得到如下结果则升级成功：

4.11.0-1.el7.elrepo.x86_64

第三步：开启BBR

执行命令：

echo 'net.core.default_qdisc=fq' | sudo tee -a /etc/sysctl.conf
echo 'net.ipv4.tcp_congestion_control=bbr' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

完成后，执行命令：

sudo sysctl net.ipv4.tcp_available_congestion_control

输出应为 net.ipv4.tcp_available_congestion_control = bbr cubic reno
再执行命令：

sudo sysctl -n net.ipv4.tcp_congestion_control

输出应为 bbr
最后执行命令：

lsmod | grep bbr

返回值有 tcp_bbr 模块即说明bbr已启动！

什么是MTProto

MTProxy 是一个专门为 Telegram 开发的轻量级代理协议，该协议根据 Telegram 自己开发的MTProto协议而设计,使用 C 语言编写。相比 ss 来说，它使用更加方便(Telegram 客户端内置该代理协议)，占用系统资源也比较少，但是只能用于 Telegram 。

官方GitHub库：https://github.com/TelegramMessenger/MTProxy

开始部署

1. 安装依赖，你需要从源代码构建一套通用的工具，以及用于开发包openssl和zlib。

   1.1. 在Debian / Ubuntu上

apt install git curl build-essential libssl-dev zlib1g-dev

​ 1.2. 在CentOS/RHEL上

yum install openssl-devel zlib-devel
yum groupinstall "Development Tools"

2. 克隆仓库

git clone https://github.com/TelegramMessenger/MTProxy
cd MTProxy

3. 编译

make && cd objs/bin

4. 获取用于连接电报服务器的密钥

curl -s https://core.telegram.org/getProxySecret -o proxy-secret

5. 获取当前电报配置

curl -s https://core.telegram.org/getProxyConfig -o proxy-multi.conf

6. 生成用户连接的代理密钥

head -c 16 /dev/urandom | xxd -ps

7. 复制下生成的密钥

8. 运行

./mtproto-proxy -u nobody -p 8888 -H 443 -S <secret> --aes-pwd proxy-secret proxy-multi.conf -M 1

• nobody是用户名。mtproto-proxy呼吁setuid()获取特权。
• 443 是客户端用于连接到代理的端口。
• 8888是本地端口。您可以使用它来获取来自的统计信息mtproto-proxy。像wget localhost:8888/stats。您只能通过环回获取此统计信息。
• <secret>是在第6步中生成的密钥-S <secret1> -S <secret2>。您还可以设置多个密钥。
• proxy-secret并proxy-multi.conf在第1步和第2步获得。
• 1是核心的数量。如果您拥有强大的服务器，则可以增加核心的数量。

9. 放通443端口[CentOS]

firewall-cmd --zone=trusted --add-port=443/tcp --permanent

10. 重启防火墙

firewall-cmd --reload

11. 查看443端口号是否开启

firewall-cmd --query-port=xxx/tcp

也可以使用查看其他选项mtproto-proxy --help。

1. 生成具有以下架构的链接：（tg://proxy?server=SERVER_NAME&port=PORT&secret=SECRET或让官方bot为您生成链接）。
2. 在Telegram上通过@MTProxybot注册您的代理。
3. 使用参数设置接收到的标签： -P <proxy tag>
4. 使用

但启动Telegram客户端使用 MTProxy 代理时输入IP、host和secret后，始终在connecting状态，在VPS上可以看到对应端口的连接都有，但就是连接不上。

1. 网上一种说法是：因为GCP时间与运行Telegram客户端机器时间不同步，可在GCP上安装个NTP服务同步时间解决。

2. 还有一种是使用阿里云服务器或者AWS服务器或GCP搭建Telegram MTProxy时，发现这个MTProxy绑定的是内网IP，解决方案也很简单，使用NAT模式就行，指定内网IP和外网IP， 启动命令行里需要加入 –nat-info :即可。

./mtproto-proxy -u nobody -p 8888 -H 443 -S <secret> –nat-info <intranet ip内网ip>:<public ip外网ip> –aes-pwd proxy-secret proxy-multi.conf -M 1

以Systemd service的方式运行MTProxy

上述的运行方式当 ssh 断开后则停止运行，以系统服务的方式启动可以持续运行而且可以开机启动

1. 创建 System service 文件

vim /etc/systemd/system/MTProxy.service

2. 添加脚本
   非 NAT 主机

[Unit]
Description=MTProxy
After=network.target
 
[Service]
Type=simple
WorkingDirectory=/opt/MTProxy/objs/bin
ExecStart=/opt/MTProxy/objs/bin/mtproto-proxy -u nobody -p 8888 -H 443  -S <secret> --aes-pwd proxy-secret proxy-multi.conf -M 1
Restart=on-failure
 
[Install]
WantedBy=multi-user.target

NAT 主机

[Unit]
Description=MTProxy
After=network.target
 
[Service]
Type=simple
WorkingDirectory=/opt/MTProxy/objs/bin
ExecStart=/opt/MTProxy/objs/bin/mtproto-proxy -u nobody -p 8888 -H 443 --nat-info <local-addr>:<global-addr> -S <secret> --aes-pwd proxy-secret proxy-multi.conf -M 1
Restart=on-failure
 
[Install]
WantedBy=multi-user.target

这里一定要注意路径问题，WorkingDirectory 和 ExecStart 的路径一定要是 mtproto-proxy 文件所在目录。

3. 重载daemons并启动 MTProxy 服务：

systemctl daemon-reload
systemctl restart MTProxy.service
systemctl status MTProxy.service

终端出现以下提示则 MTProxy 启动成功

● MTProxy.service - MTProxy
   Loaded: loaded (/etc/systemd/system/MTProxy.service; enabled; vendor preset: disabled)
   # 此处为 active（running）则服务正在运行中
   Active: active (running) since Sun 2019-01-13 00:02:41 CST; 1 day 21h ago 
 Main PID: 16083 (mtproto-proxy)
   CGroup: /system.slice/MTProxy.service
           ├─16083 /opt/MTProxy/objs/bin/mtproto-proxy -u nobody -p 8888 -H 443 --nat-info 10.146.0.2 xx.xx.xx.xx -P 43abc8...
           └─16085 /opt/MTProxy/objs/bin/mtproto-proxy -u nobody -p 8888 -H 443 --nat-info 10.146.0.2 xx.xx.xx.xx -P 43abc8...

如果启动失败的话请检查文件路径和运行命令是否正确。

4. 设置开机启动

systemctl enable MTProxy.service

使用 docker 或者 一键脚本搭建 MTProxy

使用docker请看这里：https://hub.docker.com/r/telegrammessenger/proxy/

一键脚本

wget --no-check-certificate https://raw.githubusercontent.com/lrinQVQ/script/master/other/china_only && chmod +x china_only && ./china_only

该脚本会自动设置仅限中国地区访问。

<完>

以下内容转载于 蕊希 微信公众号：蕊希

前几天我把分手三年的初恋男友从黑名单里拉了出来，当天晚上就收到了他的好友申请。

看到他好友申请的那一刻，我忽然想起一句话： “ 朋友圈未必有朋友，但黑名单里总有故人。 “

我心里很清楚，并不是所有故人都适合再见，并不是所有前任都还能做朋友，所以我没有同意，他也很默契地没有再发。

我们彼此心照不宣地选择用这样的方式，给我们曾经的感情划上了一个不那么难看的句号。

好像很多人的感情都是这样，从 “ 我们可以做朋友吗？ “ 开始，到 “ 我们还可以做朋友吗？ “ 结束，从脸红着遇见，到眼红着再见。

我们都在时间的捉弄下，成为彼此生命中被翻掉的那一页，成为 “ 过去 “ 和 “ 过去里的故人 “ 。

有人说： “ 我们这一生会遇到2920万人，而两个人相爱的概率只有0.000049。 “ 所以，在这茫茫人海中能遇见那个人，真的已经足够幸运。

有相遇，就有离别，有彼此陪伴，就有半路退场。可哪怕准备南行的他没办法陪我们一路向北，哪怕他只是陪我们走过短短一程，只是短暂地照亮了我们的世界，我们也应该心怀感激，毕竟有些人，能遇到已经是惊喜。

《山河故人》中有一句话说：” 每个人只能陪你走一段路，迟早是要分开的。” 我们总要学会接受离别，接受他已成为过去的事实。

或许每个人的黑名单中都曾住着一个这样的人吧，你深知你们不再有以后，深知他只是路过一阵子，你却会永远在心里给他留下个位置。

有些人即使不再见面，也还是永远留在心间。

1. 单击开始，单击运行，键入 regedit ，然后单击确定
2. 在注册表编辑器中，找到并单击以下注册表子项

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\RasMan\Parameters

3. 在编辑菜单上，指向新建，然后单击 DWORD 值。
4. 键入 AllowL2TPWeakCrypto ，然后按 enter 键。
5. 在编辑菜单上，单击修改。
6. 在数值数据框中，输入 1 ，然后单击确定。
7. 在文件菜单上，单击退出以退出注册表编辑器。

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\PolicyAgent

中的 AssumeUDPEncapsulationContextOnSendRule项值改为2。

今天使用git的时候，因为输错了命令然后我就强制终止了git。再过一会我拉取代码，就报错了，内容如下。

其实解决的办法很简单，直接删除 .git 文件夹内的 index.lock 文件就可以了。

友情提示：使用git工具的过程中，最好不要轻易的强制杀掉进程，不然会导致很多莫名其妙的错误。

报错内容：

fatal: Unable to create 'E:/ShimmerLS_blog/.deploy_git/.git/index.lock': File exists.

Another git process seems to be running in this repository, e.g.
an editor opened by 'git commit'. Please make sure all processes
are terminated then try again. If it still fails, a git process
may have crashed in this repository earlier:
remove the file manually to continue.
FATAL {
  err: Error: Spawn failed
      at ChildProcess.<anonymous> (E:\ShimmerLS_blog\node_modules\hexo-deployer-git\node_modules\hexo-util\lib\spawn.js:51:21)
      at ChildProcess.emit (node:events:379:20)
      at ChildProcess.cp.emit (E:\ShimmerLS_blog\node_modules\cross-spawn\lib\enoent.js:34:29)
      at Process.ChildProcess._handle.onexit (node:internal/child_process:285:12) {
    code: 128
  }
} Something's wrong. Maybe you can find the solution here: %s https://hexo.io/docs/troubleshooting.html

以下内容仅供参考，实际请遵医嘱。

以下内容仅供参考，实际请遵医嘱。

以下内容仅供参考，实际请遵医嘱。

先回答一些术前的问题

一、自己去手术可以吗？

可以，最好是有人陪更好。手术过程中和手术完一段时间其实是不痛的甚至你回家了一段时间也是不痛的，不过术后避免大量走路，最好是打车回家（包括自己有车的）或者你让别人来接你，就尽量不要自己开车了。

二、费用

不多说直接上图。

因为我走了社保所以我实际上支付了差不多两千块钱（截止目前第一次换药）

我预计我自己总共不会超过两千五到三千块钱这个区间，全国各地价格都不太一样，一般可能是两千到三千块左右

三、去什么医院

我是去的是我们当地的人民医院(三甲)，我觉得这个手术最重要的问题就是去一个正规的医院。 千万别去 一些什么所谓的男科医院。最好就是去当地正规的三甲医院就行（什么，你说你不知道你当地有那些三甲医院？百度一下吧，的确是没有三甲医院的到 公立 二甲医院也可以）。到目前为止（第一次换药，总共的花费也就两千多不走社保的话）我是走了社保的两千出头，千万别为了省钱去小诊所医院。有的小医院手术不规范（比如手术器具的消毒处理等），出现感染或者发炎之类的可能性更大，你可能还去到大医院处理发炎的伤口到时候可能还要花更多的钱，难受的还是你自己，要想真正的省钱那就用医疗保险跟去正规三甲/二甲医院做，早日康复早日回到工作岗位上才是最省钱的。

四、流程

1. 去你的社保医院开转诊证明，你的社保医院医生会问你去那个医院，干什么的你如实回答就好。
   就是这样子的（有买社保的应该都知道）

1. 带上社保卡(如果你开了转诊)，医院的诊疗卡，身份证(身份证其实带不带都可以最好是带上) 到医院的 门诊 挂 泌尿外科 （都1202年了应该大部分医院都可以在网上挂号）

2. 去挂号的科室，医生看过之后判断是否需要做手术然后跟医生预约手术时间。

3. 去交费取药医生还会给你开单抽血（血常规、凝血功能、术前检查项目）一共三项，也就是说要抽你三瓶，也不多就三小瓶，因为疫情防护还给我开了做核酸检测。

4. 去 领取备皮刀 提前 刮掉阴毛，和提前 洗好澡 ，因为在未来的一到两个星期里你都 不能 洗澡（刮阴毛的作用是使手术切口更干净，不容易感染）。

5. 手术当天 先取抽血 跟 核酸检测(如果有) 的结果（一般在医院自助打印机上自行打印），拿着去结果 门诊手术室 签到然后护士会给你拿医院的衣服换上衣服然后排队手术。

6. 提前一个小时涂皮肤麻醉药膏，医生有给我开了打的麻醉，但是手术的时候没用，可能大部分都会打麻药，但是我那个医生跟护士说麻药不用打。（这可能每个地方或每个医生都不一样我这个医生只是涂药膏没打麻醉）（这个过程也是无疼的）

7. 包皮缝合器的处理过程我就放一个知乎上的动画演示过程（这个就是你打麻醉之后开始手术到结束的过程）

8. 手术完 观察30分钟 ， 无不适 就可以回家。

纱布一共有三层(从内到外依次是凡士林纱布{即油纱}然后又一层纱布{具体是酒精纱布还是生理盐水纱布还是普通纱布就不知道了}最外层是自粘型弹力绷带，泡高锰酸钾的时候要全部拆掉直接露出伤口（因为我泡的时候不知道 只拆了外面的弹力绷带 去换药那天医生让我推迟一天换药回去重新泡后面有说到）

五、关于一些问题

1. 手术后勃起怎么办？
   答：可以用一些冰的东西敷一下，站起来走一下，分散注意力，我的医生跟我说用一点点驱风油点一下龟头。
2. 阴毛要多久长出来？（我也不知道这个问题是谁问的，反正我没关注过这个问题）
   答：Emmmmm；这个我也不知道长到正常的长度具体要多长时间，反正我做完的第二天就能看到已经长出来了第三天就像一些胡子一样有点刺手，估计一个月左右就能长成正常的长度。
3. 手术后可以立刻喝水吗？
   答：可以，但是建议少喝水，主要是为了减少小便的次数，以免弄湿敷料引起感染。
4. 发炎了怎么办？
   答：要是发炎了你就去医院啊，你问我也没用啊，我暂时还没遇到，要是我遇到了我就会检讨自己为什么会发炎，自己都不注意清洁伤口那谁能帮你？

手术完

第一天（即手术完当天）

回到家后我就睡着了 等我醒来的时候就是给疼醒的，也没多疼吧总体还是可以接受。

第二天

手术完上的第一次上厕所小便是有点痛的，但是后面尿就不怎么痛了，可能是没有包皮后尿道口太干燥皮肤粘在了一起，所以尿的时候有点痛（注意：如果你小便没上干净或者乌头没用擦干净剩于尿液你下次小便的时候可能你的尿道口周围会跟内裤粘在一起撕的时候会特别疼，因为我们的龟头是非常敏感的），然后龟头和系带的连接处有点淤血，这是正常的，拆了绷带会恢复，还有就是你上厕所会开始尿分叉具体原因我也不知道我Google了一下挺多人有这个问题的有说尿道口黏连引起也有说包扎过紧或者尿道粘膜水肿导致尿道变窄引起的但都不是大问题只要不是中到重度的水肿，出血，滴血，或者发炎都不是问题。

第三天

本来今天是去换药的但是我泡高锰酸钾的时候以为只拆外面的自粘型弹力绷带就可以了，没拆里面的沙布，然后医生让我明天吧绷带沙布拆了直接吧伤口露出来重新泡一次再来换。今天依旧该吃药跟上药。就早上起来的晨勃的时候有点疼。

第四天

早上起来依旧有点疼，然后泡高锰酸钾的时候伤口也有一点疼（也没多疼都可以接受）下午去医院换药(其实就是给你消一下毒换一个新的沙布) {我见识少，错了误喷} 然后吧自粘型弹力绷带换成医用弹力网套)。

第五天

今天早上起来不知道为什么晨勃的比较严重系带的位置特别的疼，希望伤口没有裂开。

第六天

今天因为在外面没能泡高锰酸钾，正常吃药，药不能停。

第七天

上午打算泡高锰酸钾的时候发现系带位置的沙布有一大块干了的血迹，估计是前天起来的时候导致的，泡完高锰酸钾之去了医院，就还剩那个位置没愈合完，医生让我开始加大高锰酸钾的浓度之前是1000ml/粒，现在是500ml/粒，然后给我开了两盒吃的消炎药总体来说问题不大。

第八、九天

早上起来晨勃微疼

第十天

今天早上起来的时候晨勃不疼了，但我今天给狠狠的打脸了，之前我不是说过【要是我遇到了我就会检讨自己为什么会发炎，自己都不注意清洁伤口那谁能帮你？】然后今天我发现貌似我也发炎了。继续泡高锰酸钾

第11天

早上起来的时候晨勃都不疼了，估计伤口也愈合的差不多了，但是发炎都有点化脓了医生还跟我说问题不大我都有一点不相信了。

第12天

去了一个民营的三甲医院给那里的外科医生看了一下伤口他们说有问题但问题不大，让我上厕所注意擦干净如果尿到沙布上就最好尽快换掉。

第13天

早上起来的时候晨勃不疼，但发炎跟出脓依旧没有加重。

第14天

出脓依旧，发炎没有加重。

第15天

出脓量有一点减少。

第16天

能跑能跳，已经开始适应了。

第17天

伤口已完全愈合，环也开始脱落。

第18天

炎症已经完全消了 。

第19天

一切正常以后要是没什么问题就不会更新了。（纱布没拆，每天还在持续泡高锰酸钾中）

第21天

拆纱布，完全康复。

“生而为人不只是抱歉，生而为人还请努力。”专辑简介里这样写到：生而为人，但从来没有人告诉你，你应该成为一个怎样的人。

幼儿时期在天真懵懂和温室下成长，不懂黑与白，不辨是与非开心了就笑，得不到糖果就哭，世界都是围绕你转的。少年时期开始有了学业的烦恼，但是没有生存的负担喜欢的东西就买，不喜欢的科目就不做任性是你的资本。

成年时期初出茅庐不懂社会的泥泞和沼泽，曾强出过头，也曾自以为是曾以为一身的正气可以让自己活得骄傲自在殊不知被现实当头一棒在梦想面前，是多么无力。我可能很难描述第一次听到这首歌的惊艳之感，吸引住我的耳朵，真的就只用了两句，我想听过的朋友都有所体会。第一句便是：“曾经说过不会抽的烟，都已经吸进肺里好多年”，那你想怎样的歌曲，会用这样的词，做第一句呢？肺腑之言，抱歉。

歌词说，想忘了从前，做一个俗人。是的，做个俗人成了很多人心之所想。有一句话不是这么说的吗？认清生活的真相，但依旧要热爱生活。

而这首歌曲，给人的感觉就是这样，所以才会说不只是抱歉，还请努力。生而为人，还请努力。其实成长当中的每一个自己都是真实的，唯一觉得不像是真实的是自己因为无力而想要逃避的一些东西，面对理想时好像会这样，当我高举理想的火炬，天空却刚好下起了大雨。如果你最近过得不好，那么你也得努力，努力改变现状，再坚持一下，当负数变成了0，就是全新的开始。

这首歌给你，愿你依旧倔强，且食人间烟火，生而为人，不止是抱歉，还有努力和远方。心之所向，素履前往，生之逆旅，一苇以航。让希望，炼成钢。

现不推荐使用Gitee部署了，如果可以还是用回Github吧

为何不使用GitHub部署？

由于目前国内访问GitHub速度慢，还可能被墙，所以使用Gitee来构建个人博客。Gitee类似国内版的GitHub，访问速度有保证

环境要求

• Git
• Node.Js
• Hexo框架

开始搭建

搭建环境

一. 安装 Node.Js

Node.js的官网：https://nodejs.org/zh-cn/

进入Node.js的 官网 下载长期支持版（也就是稳定版）

1. 打开刚下载完的安装程序
   选择 Next（下一步）

2. 勾选 I accept the terms in the License Agreement 然后继续 Next

3. 选择安装路径我这里因为演示就选择默认的安装路径了 选择完安装路径之后继续 Next

4. 到了这一步我们默认就好；继续 Next

5. 这里我们选择 Install（安装）

6. 这里我们选择 是

7. 等待安装完成。

8. 安装完成后选择 Finish 关闭安装程序

9. 按快捷键 Win+R 打开运行 在运行里输入 cmd 然后回车

10. 测试 Node.js 是否安装成功
    在命令行里输入

node -v

如能正常显示版本号就代表安装成功我这里安装的是15.6的版本所以显示的是15.6 你们的请根据实际情况只要能正常显示版本号就可以了。如出现 “node -v”不是内部或外部命令，也不是可运行的程序或批处理文件。就代表没有安装成功。请卸载之后重新安装

二. 安装 Git

1. 进入 Git 的 官网 选择 Download 2.30.1 for Windows 下载Git安装程序

注意：由于国内访问GIt官网的下载速度奇慢，所以这里我推荐使用淘宝镜像进行下载 （点我下载）
从哪下载安装包看你个人的选择如果你愿意一直等那你可以选择从官网下载，我个人比较推荐使用国内的淘宝镜像源。

下载完成后打开安装程序 我们默认一直 Next 就好 所有的东西都不用修改

详细的安装步骤你们可以看这里：https://www.cnblogs.com/xueweisuoyong/p/11914045.html 他的版本是2.24.0.2 安装过程都大同小异。

三. 创建Gitee账户

Gitee官网: https://gitee.com/

注册过程我就不放图了；注册的姓名我建议使用全英文，姓名你可以随意起的但你一定要记住你起了什么姓名，建议不要使用自己的真实信息。

注册完成之后进入设置，添加邮箱

添加完邮箱之后在下面把主邮箱跟提交邮箱都设置成你刚刚添加的如下图所示

修改完成了之后你会在你添加的邮箱旁边看到 主邮箱 跟 提交邮箱两个标志

四. 使用Git创建SSH-RSA密钥然后复制到自己的Gitee里

1. 在桌面空白的地方右键你会看到一个叫 Git Bash Here 点击打开它，如果你的右键菜单中没有那你也可以进入Git的安装目录里找到一个叫 git-bash.exe 的程序打开它也是一样的。

注意：.exe为程序的后缀名，我这里是安装在D盘，请根据你的实际情况查找你的路径

2. 打开Git之后输入以下内容

ssh-keygen -t rsa -C “你刚刚在Gitee添加的邮箱地址“

然后会提示

Creates a new ssh key using the provided email # Generating public/private rsa key pair.
这个的意思是：使用你提供的电子邮件创建新的ssh密钥 #生成公共/私有rsa密钥对。
 
Enter file in which to save the key (/home/you/.ssh/id_rsa):
这个的意思是：保存密钥的文件（/home/you/.ssh/id\u rsa）

我们可以直接Enter（回车）就行。然后，会提示你输入密码，如下: 这个密码可以选择输入也可以不输入，如果输入了请务必记住你的密钥密码。

注：输入密码的过程中不会显示的，光标也不会移动，你以为没有输实际上已经输入了，你输入完直接回车即可

Enter passphrase (empty for no passphrase): [Type a passphrase]
这里我们因为演示就直接回车不输入密码
如果你输入了密码会提示你再次输入密码进行验证，如下；如果没有输入密码就不会提示下面这一行

Enter same passphrase again: [Type passphrase again]

等待一小会你就会看到类似以下内容

3. 我们在存的路径里用记事本打开 id_rsa.pub 如下图所示，

4. 然后我们将里面的内容 全部 复制到Gitee的SSH公钥里

五.安装Hexo框架

1. 使用 Win+R 打开运行窗口输入 cmd

2. 打开cmd后输入以下命令进行安装，下载过程可能会比较慢。请耐心等待 也可以使用淘宝的镜像源，具体方法请自行Google/Bing，我这里就直接使用官方的源。

npm install hexo-cli -g

3. 安装完成之后你也可以输入命令来查看是否安装成功

hexo -v

如出现以下内容，说明安装成功。

六. 创建hexo文件夹

这里开始就正式部署了，不用害怕错了，错了大不了把整一个文件夹删了重新来。

1. 在电脑任意地方创建hexo文件夹（文件夹名可随意起，最好是英文的，我这里就叫bolg） 我这里就直接在 D盘 根目录里创建这个文件夹我们在D盘的地址栏内输入 cmd 然后回车如下图

2. 打开 cmd 之后输入命令进行安装

注：blog 是文件夹的名称 这里你们可以随意修改但建议是全英文的。

hexo init blog

3. 安装完成之后使用命令进入到刚刚创建的文件夹里，如下图，如返回 D:\你的文件夹名称> 就代表成功进入

cd blog

4. 然后继续使用命令来安装hexo的依赖，

npm install

5. 依赖安装完成之后即可运行hexo进行测试。

hexo s

或

hexo server

注意：在Hexo运行的过程中cmd命令窗不能关闭 要一直运行着不然是无法访问的

6. 当你在浏览器中看到这个页面说明你的本地博客已经成功搭建了。我们在CMD命令窗里按Ctrl+C或直接关闭掉命令窗，停止运行。

七、创建仓库

1. 修改个人空间地址 进入设置页面 修改一个你自己喜欢的用户名（这里不能使用中文）。

2. 创建的仓库名建议跟你的Gitee账户的用户名一致，这样子部署的才会是在域名的根目录上而不是在二级目录上（用户名就是你刚才修改的那个）（因为我这里已经创建过一个仓库了所以我这里就创建一个名叫CS的仓库你们就正常的创建即可）。

3. 创建完之后理论上它会不会自动跳转到仓库里，如果没自动跳转那你就在上方点击我的然后选择相应的仓库，进入仓库之后你们会看到仓库未初始化，我们到 管理 里面进行仓库的初始化。（初始化完成后我们回到 代码）

八、修改config.yml文件并做首次推送。

1. 在博客的根目录里找到 _config.yml 文件右键使用文本编辑器打开如 (EditPlus, Visual Studio Code)等，如果没有这些软件你可以去下载一个或者简单粗暴直接使用记事本打开(TXT)，我这里还是建议大家使用文本编辑器。这里为了迎合小白就使用TXT打开了。

2. 打开之后找到并修改以下内容。

# Hexo Configuration
## Docs: https://hexo.io/docs/configuration.html
## Source: https://github.com/hexojs/hexo/

# Site
title:  # 这个是页面标题
subtitle: # 这个是页面副标题
description:  # 这个是百度等搜索引擎的介绍
keywords:  # 这个是百度等搜索引擎的搜索关键字
author:  # 这个是该文章的作者
language: zh-CN  # 这个是博客的语言
timezone: 'Asia/Shanghai'  # 这个是时区  我这里输入的是亚洲/上海

# 以上内容都可自定义

然后我们修改推送地址

# Deployment
## Docs: https://hexo.io/docs/one-command-deployment
deploy:
  type: git  # 这个是推送方式我们在这里输入 git
  repo: # 这个是仓库的地址我们可以在仓库的左上角有一个 克隆/下载 点击之后选择HTTPS然后在地址后面有一个复制，复制了之后粘贴到这里。
  #注：地址后面的那个.git 须要保留不能删除
  branch: master  # 这个是分支，可以在仓库的左测找到。

如下：

修改完以上信息之后我们保存并使用命令推送到仓库里。

在博客根目录的空白地方右键，选择 Git Bash Here

然后在命令窗内输入以下内容，然后回车

hexo cl && hexo g && hexo d 

这些命令分别是 清理缓存、生成缓存、推送到仓库 ，前面两步的作用就是刷新他的内容 后面一步就是推送到仓库 “&&” 这个是连接符 用来将多个命令连接起来的用的 ，回车运行之后正常的话会弹出来一个窗口让你输入Gitee的账号密码，你输入就可以了 ，账号我建议你们使用邮箱 不要使用手机号码 有时候会出错。输入完账号密码之后回车它会再次运行当你看到以下信息之后说明已经推送成功了，你可以到仓库里刷新页面就可以看到有文件了。

然后我们去到 服务 选择 Gitee Pages 进行部署

部署完成之后会自动给你分配一个地址（如下）

我们吧这个地址复制到 config.yml 文件的以下地方

# URL
## If your site is put in a subdirectory, set url as 'http://example.com/child' and root as '/child/'
url:   # 这里输入Gitee给你分配的地址，https://也不能删除
root: /
permalink: :year/:month/:day/:title/
permalink_defaults:
pretty_urls:
  trailing_index: true # Set to false to remove trailing 'index.html' from permalinks
  trailing_html: true # Set to false to remove trailing '.html' from permalinks

再重新使用命令推送一次

hexo cl && hexo g && hexo d 

推送成功之后我们在Gitee里刷新一下仓库然后进入到 Gitee Pages 里选择更新。等它更新完成之后就可以在使用它给你分配的域名访问了。

<完>

安装openssh和openssh-server

dnf -y install openssh
dnf -y install openssh-server

卸载openssh和openssh-server

dnf -y remove openssh
dnf -y remove openssh-server

设置ssh，打开登录功能，保持默认配置即可。
编辑/etc/ssh/sshd_config文件：

RSAAuthentication yes
PubkeyAuthentication yes

允许root通过 SSH 登录，如果禁止root远程登录，那就设置为 no

PermitRootLogin yes

在之前向舍友借来你的第二本书《总要习惯一个人》读完后相较于第一本书《愿你迷路到我身旁》感觉并不是特别好，那会读完想着还是太嫩了吧，当我还在考虑真要不要买下一本的时候，看到了你的新书预售，不自觉的倒数起来，预售的时候，也没有犹豫太多就下手了。

读完这本书，发现在书中不止是看故事，同样看着自己的成长。就像我看开篇就知道倪安好是谁，因为有些故事只有看过你之前的书的人才知道那不止是故事。既然我们都是年轻人，都在试错，都在成长，那便陪伴彼此吧，或许我的陪伴微不足道，那就小小的许你一个诺，虽然你是90后而是00后，我们都经历着人生中的不同阶段，但我懂，不止是听故事。

不论是谁，对于我们，能陪伴而行的不过是一程罢了。到最后终究还是免不了一场离别，或天各一方，或生死两茫茫。既然有缘相见，相识，相知，就珍惜这一段旅程。也许在将来某个日落时分，那时的我们已白发苍苍，手上端着一杯香浓的咖啡，或是一杯清淡的茶，轻饮一口，而这时，却无意间想起，回忆起那些人，那个人，那些在你的生命中留下过印记的人，那个曾陪你度过那段旅程的人。

从翻开这本书就找到了和第一本书《愿你迷路到我身旁》同样的亲切感。是感觉像在身边的蕊希，是感觉像我的朋友一样的蕊希，是感觉很贴近的蕊希，是我有感同身受的蕊希。
最后套用书中的一句话“这本书有一个游戏规则：你不能从这里带走任何东西，但你可以放下很多。

因为只能陪一程。家人，朋友都是生命中最珍贵的存在，但只有一程。在拥有的时候，就好好珍惜，不要到了失去时才追悔莫及。毕竟，时间不会容人多加考虑。趁着这共处的时光，珍惜，那仅有的一段行程。

你在预售文章里写下过这么一段话

我只是一个努力在笔墨间寻求灵魂救赎的普通人。我唯一期盼的，是你能在字里行间找到些你试图探求的答案，愿它能解你些许迷思，愿它能陪你走上一程。

我在写的是你我老套的人生，我不会编故事，我只是芸芸众生里一个平凡的记录者。希望我能永远满怀真诚与善意地写作，记下别人的感动，记下别人的苦痛，记下成败得失，记下风光落魄，记下江湖险恶，也记下每个人对自己和生命的许诺。

而我很幸运，我的记录，有你愿意来读。

你将要拿起的这本书里，没有新世界。你走进的，也不是我的世界。它要给你的，是你的世界。

我也相信，
明天的明天，
依旧是艳阳高照的晴天。

摘抄书中的一段：

原来，每个人的血液里都流淌着很多闪着金光的经历，原来，爱是会被深深印刻的，原来，爱是证明你来过，最好的证据。

你回不回来不重要。

你，来过就好。

如果当时我挽留，是不是结局就会有所不同，是不是你就可以答应我哪怕试一试？如果我说的不是“对不起”，而是“我真的很喜欢你”，会不会你就心软就舍得不走？如果窝薄情寡义看淡人世间的分分合合，是不是就能潇洒坦荡将故事连同旧人一并埋葬？

可惜，没有如果。

她没有挽留，他没有心软。

可惜，没有如果。

她太长情，长到现在都忘不了。

“咔咔咔，今天不说了，难受。

“改天，你请我喝酒，我给你讲故事”

“故事，就酒”

你把你的时间放在哪，你的未来岁月就在哪！

你看，真正开心的时刻，是会让人有发自内心的微笑的。你看，真正让人喜悦的，是人生每一个关键阶段的成长。你看，努力的感觉，多好！

虽然这一路也跌跌撞撞，四处碰壁也有过狼狈不堪，但总能幸运地化险为夷，总能再大事面前拥有些许好运气。所以生活给过我怎样的打击，内心也总是感激的。

谁的成长不是这样呢，带自些鲁莽的不知天高地厚的自信，怀着似乎能跨越崇山峻岭甚至视死如归的决心，然后路跌例再路舔原伤口，一路美弱地被现实扇着耳充，又路倒强地咬牙坚持告诉自己“能行”。我们看过冷眼听过谎言。我们真切地感受过世态炎凉、人心叵测。我们白白付出过，我们有过损失惨重的时候，我们也曾和不靠谱的同龄人一-起共事，我们陷入过巨大的迷惘和不知所措，我们有过要放弃的念头和无数个走人死胡同的时刻，我们甚至也曾有过对彼此的不满和质疑。

但，好在，我们还在。

并且，我们正在用更好的姿态站在我们此刻的人生里。

掉的美好和对未来生活的宣言。

我曾在朋友圈里发过一句话:

“谢谢困难的时候站在我身边陪我解决问题的人。”

他们不是一定要在， 他们没有义务必须陪你，但他们在你身处险境的时候没有犹豫。

而这，是我能想象到的我的世界里最大的真挚和浪漫。

我常常跟人分享我每个人生阶段的心理感受，我是真的很感激我曾经陷人过的所有困境，我是真的觉得，我能走到此刻，大多都仰仗它们。

我不希望我是一个在我接下来的人生里不必经历苦难的人。我不希望我开始变得安逸，变得不再拥有对抗甚至绝地反击的力量。

我希望自己永远燃烧，一刻不停地， 无比旺盛地。

看过一句话: 好是更好的敌人！我希望我一直有敌人！

愿我们能在彼此拥有的时候，倾尽所有！

一个愿意成全别人的人，是一个在内心里对自己充满信心的人！

所以你说，人生中的同伴是什么?

是陪你跨过大江大河，陪你翻山越岭的人吗?

不是的，不必那么轰轰烈烈。

是无论顺遂险阻，都能陪你起过的人。

即使身在远方，也都能在各自的天地里努力生长。

希望我们能嬉皮笑脸地面对人生的难。

希望我们一直拥有不自量力的、向生活还手的勇气。

你路过了我的夜晚，给我点了一盏灯。从此，我心里藏着一把火，走向有别人的远方！

你得按自己真正的方式度过一生，你才能不负此生！

希望缘尽仍留有慈悲！

一心付出，不求回报的感情是不存在的。得不到回应的人，早晚都是要离开的。

任何关系都是这样，希望我们在已经拥有了的时候，依然能保有想要拥有时的热枕和认真。

当遇到一些肆意践踏你善意的人时，就要告诫自己，必要的时候，请学会有原则地残忍。

养成了一个习惯，不快乐的时候不发朋友圈，也不发微博。

协同进化，才是长久之道。

那不是卑微，那是我对自己和我们的爱情的最大尊重和虔诚。

当你见过一个人的脆弱狼狈之后，你就不会因为她的强势苛刻而大惊小怪。成年人的世界，见到一个人的铠甲容易，但要看到一个人的软肋却很难。

优秀从来都不是被爱的原因，而是结果。如果你喜欢的人，不能让你变得更好，那他一定配不上你的喜欢。

我不想做一个永远被生活套住的人，如果我人生的眼界永远只在我目之所及的当下，那我不认为我能够做出更多影响他人的事情，我不认为我会对那样的我感到满意甚至骄傲。

如果已经来不及认真地年轻，那就想想如何认真地老去。

身体和灵魂不能只有一个在路上，心里和脚下都有远方的人，才有资格说：长路漫漫，而我无惧雨雪风霜。

谁的成长不是这样呢，带着些鲁莽的不知天高地厚的自信，怀着似乎能跨越崇山峻岭甚至视死如归的决心，然后一路跌倒再一路舔舐伤口，一路脆弱地被现实扇着耳光，又一路倔强地咬牙坚持告诉自己“能行”。

一个愿意成全别人的人，是一个在内心里对自己充满信心的人。

爱是我允许你心里留有他人的位置，但那位置绝不能影响你我感情里的信任与忠诚。

若无相欠，怎能相见。

曾经看过一个问题： “ 在一起久了，感情会变淡，是所有情侣都无法逃脱的宿命吗？ “

有个回答真实又扎心： “ 是啊，一开始你皱个眉，Ta都小心翼翼，到后来你哭了，Ta还无动于衷。 “

这可能就是爱情里最可怕的真相，在一起久了，什么都激不起波澜。让人忍不住感叹，还是刚认识的时候最好，拘谨中带着真诚，礼貌中带着热情。

昨天和朋友小洁一起吃饭，聊起相恋7年的男朋友，她忍不住吐槽起来： “ 一开始，我有任何一点小情绪，他都会刨根问底，生怕我受委屈，现在能让我自己闷闷不乐一整天。

一开始，我去给他做饭干家务，他感动到不行，总是抢着干，现在衣服碗筷一堆，就等着我洗。

在一起时间长了，因为他不接电话、不回消息生气成了无理取闹；迁就他的喜好，照顾他的情绪成了理所当然。

以前一直以为在一起时间久了，才懂真情可贵，可现在才发现，放久了的真情，最不值钱。 “

小洁的喋喋不休，让我忽然想起纳兰性德在《木兰词》里写的一句诗： “ 人生若只如初见，何事秋风悲画扇。 “

如果人与人之间能一直像初见时那样美好，那么也许就不会经历什么伤感和苦涩了。这可能是很多人都会在感情中犯的错误，因为太过熟悉，而变得太过无所谓。

我们都以为时间会自动为感情保值，但实际上却不得不面对 “ 感情总会过期 “ 这个事实。

电影《重庆森林》里有一个经典的桥段，何志武刚被分手之后，独自坐在台阶上喃喃自语：

• 不知道从什么时候开始，每个东西上都有一个日子，秋刀鱼会过期，肉罐头会过期，连保鲜纸都会过期，我开始怀疑，这个世界上，还有什么东西是不会过期的？

几乎所有的东西都会过期，也包括感情。每段感情的开始都是新鲜的，就像你买一本新书，总会心血来潮地翻看两页；你买到一件新衣服，总会忍不住多穿几次。

可是时间久了，再好看的书，也会变乏味，再漂亮的衣服，也没那么喜欢了。

仔细想想，感情也是这样，刚认识的时候，无话不谈，时间久了，相顾无言；刚认识的时候，恨不得每天粘在一起，时间久了，可能几天都不联系。

好像一段感情一旦错过了最佳保质期，那两个人的结局便会不可避免地走向终结。

刚开始一段感情时，我们都没学会珍惜，只会在把一段最好的感情消磨、糟蹋之后，才开始感叹，人生若只如初见该有多好。

我曾经看过一个心理学效应，叫 “ 边际效应 “ 。意思是说，人在第一次接触到某个事物时，情感体验会比较浓烈，但第二次接触时会淡一些，第三次会更淡，以此类推。

这说明我们接触相同事物的次数越多，情感也会变得越来越乏味。感情也是这样，前半段就抵达了顶峰，后面任由你往哪走，都是下坡。

乍一看，两个人的感情随着时间被削减，像是自然中的不可抗力，人性使然。可是如果维系一段感情的仅仅只是初遇时的心动，那这并不是爱情。

有人说： “ 爱上对方的优点，是一段感情的开始，爱上对方的真实，才是爱情的开始。 “

一段能够走下去的感情，无非是你看见了Ta的美好，包容了Ta的缺点，打磨了彼此的棱角。

我们不会因为熟悉，而彼此怠慢；不会因为习惯，而彼此忽视，我们不再感慨、怀念初遇时的美好，而是用心地去经营当下，用力地去爱面前的这个人。

我对于博客的态度

• 每次有不会的问题上网查阅资料时总能看到一群大佬们发布的种博客文章，布局十分漂亮，我就在想什么时候我也能有一个这样的博客，现在我的愿望实现了，在我看来博客不只是推送一篇文章这么简单，它也是生活的一种记录，我不想在以后的工作中或者给别人讲述我的成长经历时，没有实实在在的东西。
• 因本人写字不太好看，所以我也希望博客能代替日记陪伴我走下去，希望我能在博客的陪伴下努力生长，虽然现在的我也小有成就，但几年后的今天我相信我也可以成为别人口中的大佬！

目标

• 成为像马云那样对钱不感兴趣，从来没碰过钱的人，啊呸！成为那能照顾她保护她的人; 成为一个能养的起自己照顾好父母服务好社会的好公民，顺便再做个程序猿大佬。

我对分享的看法

我是比较希望与别人分享一些东西的，无论是知识或是一些平常琐事，我会把一些自己认为有必要记录的东西都写下来，也是对知识的一种巩固吧。

以前一直觉得喜欢与别人分享的人适合去做人民教师，因为这个职业一辈子都在与别人分享自己的知识。

后来渐渐发现对于大多数人而言分享是一种本能，无论你想与他人分享什么内容，在这个过程中都能从分享这一行为获得愉悦感，甚至能让别人感到快乐

分享的本质其实就是倾诉与宣泄。从这个角度来看，世间应该不存在讨厌分享的人，不喜欢分享无非是没有找到愿意聆听或适合聆听的人而已。

Java包括Java Runtime Environment（JRE）和Java Development Kit（JDK）。 如果您只想运行Java程序，那么您需要JRE，如果您是Java开发人员，那么您将需要JDK，其中包括JRE和开发/调试工具和库。

Java，OpenJDK和Oracle Java也有两种不同的实现，它们之间几乎没有区别，只是Oracle Java有一些额外的商业功能。

如果您不确定要使用哪个Java实现和版本，一般建议坚持使用Debian 9上提供的默认OpenJDK版本。

安装OpenJDK 8 JDK

sudo apt install default-jdk

安装OpenJDK 8 JRE

sudo apt install default-jre

1. 首先现在Java存档

curl -L -b "oraclelicense=a" -O http://download.oracle.com/otn-pub/java/jdk/8u181-b13/96a7b8442fe848ef90c96a2fad6ed6d1/jdk-8u181-linux-x64.tar.gz

2. 接下来，为Java安装创建一个目录

sudo mkdir /usr/local/oracle-java-8

3. 将Java .tar.gz文件解压缩到先前创建的目录

sudo tar -zxf jdk-8u181-linux-x64.tar.gz -C /usr/local/oracle-java-8

4. 解压缩文件后，运行以下命令以创建新的替代方案

sudo update-alternatives --install "/usr/bin/java" "java" "/usr/local/oracle-java-8/jdk1.8.0_181/bin/java" 1500
sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/local/oracle-java-8/jdk1.8.0_181/bin/javac" 1500
sudo update-alternatives --install "/usr/bin/javaws" "javaws" "/usr/local/oracle-java-8/jdk1.8.0_181/bin/javaws" 1500

卸载Java

sudo apt remove default-jre

一. 激活 Windows

如果你的 Windows 是 VL 版本，那么只要在管理员权限的 cmd 或者 powershell 中执行下面两个命令就可以了。

执行完第一个命令后要等弹出提示窗，期间电脑必须联网。

slmgr/skms kms.lsho.top
slmgr /ato

如果不是 VL 版本的，那么需要更换密钥获取你对应版本的 KEY，操作如下：

运行以下命令查看系统版本：

wmic os get caption

在文末找到对应的 key，在管理员权限的 cmd 或者 powershell 中执行下面命令安装 key：

slmgr /ipk xxxxx-xxxxx-xxxxx-xxxxx

然后跟上面说的一样设置 kms 服务器地址，激活。

例如：新装windows10专业版之后如何激活

如果你是新装的或者已经安装好了windows10专业版那么只需要复制下面命令在直接管理员权限的cmd或者powershell中执行即可。

slmgr.vbs /upk

slmgr /ipk W269N-WFGWX-YVC9B-4J6C9-T83GX

slmgr /skms win.kms.pub

slmgr /ato

二. 激活 Office

你安装的 Office 必须是 VOL 版本，否则无法激活。

可以从 msdn.itellyou.cn 上下载。

在管理员权限的 cmd 或者 powershell 中执行下面命令，进入 32或64 位 Office 2016 的安装目录。
(根据你安装的office是32位还是64位进入其中一个目录就可以了)：

32位执行如下命令:

cd "C:\Program Files (x86)\Microsoft Office\Office16"

64位执行如下命令:

cd "C:\Program Files\Microsoft Office\Office16

在管理员权限的 cmd 或者 powershell 中执行下面两个命令。执行完第一个命令后要等待命令行出现反馈提示，期间电脑必须联网。

cscript ospp.vbs /sethst:kms.lsho.top

cscript ospp.vbs /act

如果提示看到 successful 的字样，那么就是激活成功了，重新打开 office 就好。

Windows VL 密钥对照表(以下内容来自微软官方公开的序列号，请放心使用)

点击查询微软官方公开序列号

CCleaner

C2YW-N8ZC-FMC7-AHR9-UZPC

VMwaer16

ZF3R0-FHED2-M80TY-8QYGC-NPKYF
YF390-0HF8P-M81RQ-2DXQE-M2UT6
ZF71R-DMX85-08DQY-8YMNC-PPHV8

以下内容来源: IT技术分享社区
文章作者: IT技术分享社区
文章链接: https://programmerblog.xyz/archives/wl001
本文章著作权归作者所有，任何形式的转载都请注明出处。

1. 网络安全威胁介绍

非法授权访问：没有预先经过同意，就使用网络或相关的计算机资源就是非授权访问。主要有以下几种形式：身份攻击、假冒、非法用户进入网络系统进行违法操作、合法用户以未授权的方式进行操作。

信息泄露丢失：主要是指敏感计算机数据有意或无意中被泄露出去或丢失。

破坏数据完整性：采用非法手段窃取对计算机数据的使用权、删除、修改等重要信息，以取得有益于攻击者的响应；恶意添加、修改数据，以干扰用户的正常使用。

拒绝服务攻击：不断对网络服务进行干扰，从而改变其正常的作业流程，执行无关的程序是系统响应减慢甚至崩溃，影响正常用户的访问，甚至排斥合法用户进入系统或不能得到相应的服务。

利用网络传播病毒：通过网络传播计算机病毒，破坏性非常大并且用户很难防范。

2. 网络安全控制技术介绍

防护墙技术：防护墙技术是目前维护网络安全最重要的手段之一。根据网络信息保密程度，进行不同安全策略的多级保护模式。合理的使用防火墙可以经济、有效的保证网络安全。

加密技术：加密技术是网络信息安全主动、开放的网络防护手段，对敏感数据应采用加密处理，并在数据传输是采用加密传输。加密技术主要有：对称密钥的加密算法、非对称密钥的加密算法。加密技术具有成本低、灵活、硬件加密效果高等优点。

用户识别技术：主要是识别用户是否属于系统的合法用户，目的是防止非常用户进入系统。一般采用基于对称密钥加密或公开密钥加密的方法。比如Kerberos、PGP等方法。

访问控制技术：主要是控制不同用户对信息资源的访问权限。可以到文件、图片、应用程序等。

网络反病毒技术：基于网络的快速发展，互联网上的网络病毒越来越多，针对这些问题研发了很多的防计算机病毒的软件。

网络安全漏洞扫描技术：可提前预知主体受攻击的可能性和具体的风险，提前采取措施，从而尽可能避免计算机系统被攻击的风险。

入侵检测技术：入侵行为主要是对系统资源的非授权使用。入侵检测技术可以检测出系统中违背系统安全性规则或受到安全威胁的活动，然后进行安全评估，从而提前采取措施。

3. 计算机防火墙技术介绍

防火墙：建立内外网络边界的过滤封锁机制。

作用：根据安全策略决定外部网络内否访问内部资源、内部网络能否访问外部的资源。其实就是内部、外部网络中间的一个屏障进行通信的过滤机制。

防火墙发展阶段：包过滤防火墙、应用代理网关、状态检测技术。

防火墙系统的组成：过滤路由器、代理服务器组成。

4. 入侵检测与防御技术介绍

入侵检测系统（IDS）：是防火墙之后的第二道安全屏障，通过从计算机系统或网络中的若干关键点收集网络的安全日志、用户行为、网络数据包、审计记录等信息并对其进行分析，从中检查是否有违反安全策略的行为和遭到入侵攻击的迹象，入侵检测系统根据检测结果自动做出响应。

IDS功能：对用户和系统行为的监测与分析、系统安全漏洞的检查、扫描、重要文件的完整性评估、已知攻击行为的识别、异常行为模式的统计分析、操作系统的审计跟踪、以及违反安全策略的用户行为的检查等。

又到了年度一年总结的时候了。时光转瞬即逝，就这样和它说声道别了。

2020年，自我出生以来最特殊的一年，这一年，或许有遗憾，有伤痛，有喜悦。无论是好是坏，在最后的这一个星期里也该放下包裹，拾起该拾起的东西，迎接新的一年了。

2020

• 我们共同经历了新冠，我们一起携手控制了疫情。

在某种意义上，你我也算是生死之交了

今年

我们喝着 “最便宜” 的咖啡
租着 “最贵” 的房子
一边向罗先生学习时间管理
一边向潘夫人了解爱拼才会赢
听过12点后深夜的寂寞
也看过一只企鹅对着瓶辣椒酱乱摸
对外，我们欣赏着懂王的闹剧
对内，我们观摩着深谙武德的老同志
偶尔一起去爬山，证明还有机会
但一旦半路遇到蚂蚁,机会就很渺茫了
我们都调侃自己是打工人
但其实心里清楚,我们都是追梦人

对于我来说，20 年可能确实给我带来了一些伤痛叭的。上半年完比赛回国，新冠疫情，全国封城，在广州呆了半年 国内各种比赛取消的取消 部分也从线下变成线上，我们尽力去认真地去把握好每一次比赛机会。毕竟，留给我们自己的机会真的不多。

其实，我自己也没想到从国内赛事到国际赛事能这么顺利。

在上半年封城期间 我用自己所学到的一点 Web 知识，建立了这个博客，在学习 Web 的同时，试图找一个人少的地方去倾述自己的内心。

上半年总结成一句话就是：迷幻的跟书一样。

下半年我重新开始管理团队，整合团队核心也有许多小伙伴的新加入，在下半年我们一共推出了17个公益性项目作品，23个免费作品和14个付费作品

我们也申请到了一些资质，基于GitHub上的大佬项目搭建了6个免费开源的功能供大家使用。

2020年7月 团队里面购买了第二台服务器，为以后发展活动做扩展
2020年8月 开发团队开始招慕
2020年9月 团队博客正式上线
2020年10月 网易云音乐API接口正式上线
2020年11月 资源下载正式上线，云上码库正式提上日程
2020年12月 云上码库正式进入内测阶段

在过去的一年当中我们的投稿邮箱几乎天天爆满，我们为许多人解决了技术上的问题，也为许多人聊他们感情上的问题。

我仍然清楚地记得2019年跨年时候的场景，我和组里面的几十个人聚在家里，一起煮了火锅，开了两箱啤酒，说着关于新年的愿望，聊着比赛结束后该干嘛，那时的我们没人知道接下来会发生的事情。说着要去国外旅行的朋友被困在老家好几个月，如今回头看，怎么觉得像是一场被安排好的冲突戏。

今年也许你们身边有人离开，有人刚来，有人陷入低谷，有人走向高峰。有的家庭痛失挚爱，有的家庭拥有新生。

时间推着我们一刻不停地往前，无人能幸免。那些岁月赋予我们的痕迹，希望不只是生理上的皱纹和衰老，也会有时间淬炼的坦然和大方。

在过去的2020也许，你曾在深夜的被窝哭到鼻塞；也许，去年的计划，搁置到今天仍没机会实现；也许，曾说好 " 永远 " 的人，如今已成陌路。

意外打乱了所有的计划，却也打通了一条 " 我比想象中厉害得多 " 的通道。

但还好，在低谷哭的人，没在低谷倒下；被迫搁置的事，到今天你仍然饱有热情；而旧人的离开，刚好给对的人腾出了相爱的位置。

昨天再糟糕，都会成为过往，今天的不如意，也会随着今天，成为下一个 " 昨天 " 。

一切都会过去，一切终将过去。

而我们，终将穿越生活里所有好好坏坏的时刻，抵达那个叫做 " 圆满 " 的终点。

2020还有一个星期就要结束了，没做完的事情要留到明年再做了，没见到的人也只能说明年再约了，没完成的计划可能要重新安排了。

站在新旧交错的关口，总是觉得神奇，哪怕之后的日子依旧平凡普通，但每个人都需要这个重新开始的机会，需要一个和过去说再见的时刻。然后你看着时间 " 啪 " 的一下从2020跳进2021。

其实，我还没做好十足的准备迎接新的一年，不知道你是不是也一样？但仍然诚意满满地期待与众不同、不可复制的未来的每一天。

2021我们会继续推出更好的作品，提供更多的公益/免费服务

时间不在，记忆永存

2021，一往无前

什么是跨域？

出于浏览器的 同源策略 从一个域名的网页去请求另一个域名的资源时域名、端口、协议任一不同，都是跨域问题，即便两个不同的域名指向同一个 ip 地址，也非同源。同源策略/SOP（Same origin policy）是一种约定，由 Netscape 公司 1995 年引入浏览器，它是浏览器最核心也最基本的安全功能，现在所有支持 JavaScript 的浏览器都会使用这个策略。如果缺少了同源策略，浏览器很容易受到 XSS、 CSFR 等攻击。

比如：

域名：

• 　主域名不同
  从 www.baidu.com 访问 www.sina.com 下的文件

• 子域名不同
  从 www.123.baidu.com 访问 www.223.baidu.com 下的文件

域名和域名ip

用baidu.com的域名访问网页但用百度的服务器IP地址调取文件

端口：

　从 baidu.com8080端口访问 baidu.com8081端口下的文件

协议：

　用http的协议访问 baidu.com又用https的协议去访问 baidu.com下的文件

备注：
　1、端口和协议的不同，只能通过后台来解决
　2、localhost和127.0.0.1虽然都指向本机，但也属于跨域
　

如何解决跨域问题？

跨域实践： Fiddle 处理前端本地开发跨域问题

1. jsonp跨域
   JSONP（JSON with Padding：填充式JSON)，应用JSON的一种新方法，
   JSON、JSONP的区别：
   　1、JSON返回的是一串数据、JSONP返回的是脚本代码(包含一个函数调用)
   　2、JSONP 只支持get请求、不支持post请求
   　(类似往页面添加一个script标签，通过src属性去触发对指定地址的请求,故只能是Get请求)

2. nginx反向代理：
   　　比如访问 baidu.com1. 需要调用 sina.com下的文件可以写一个接口，比如 /server.php，由这个接口在后端去调用 sina.com下的文件并拿到返回值，然后再返回给 index.html
   　　

3. PHP端修改header
   　　header(‘Access-Control-Allow-Origin:*’);//允许所有来源访问
   　　header(‘Access-Control-Allow-Method:POST,GET’);//允许访问的方式
   　　

4. document.domain
   跨域分为两种，一种xhr不能访问不同源的文档，另一种是不同window之间不能进行交互操作;
   　　document.domain主要是解决第二种情况，且只能适用于主域相同子域不同的情况；
   　　document.domain的设置是有限制的，我们只能把document.domain设置成自身或更高一级的父域，且主域必须相同。例如：a.b.example.com中某个文档的document.domain可以设成a.b.example.com、b.example.com 、example.com中的任意一个，但是不可以设成c.a.b.example.com，因为这是当前域的子域，也不可以设成baidu.com，因为主域已经不相同了。
   兼容性：所有浏览器都支持；
   优点：
   　可以实现不同window之间的相互访问和操作；
   缺点：
   　只适用于父子window之间的通信，不能用于xhr；
   　只能在主域相同且子域不同的情况下使用；
   使用方式：
   　不同的框架之间是可以获取window对象的，但却无法获取相应的属性和方法。比如，有一个页面，它的地址是http://www.example.com/a.html ， 在这个页面里面有一个iframe，它的src是http://example.com/b.html, 很显然，这个页面与它里面的iframe框架是不同域的，所以我们是无法通过在页面中书写js代码来获取iframe中的东西的：

<script type="text/javascript">
    function test(){
        var iframe = document.getElementById('ifame');
        var win = document.contentWindow;//可以获取到iframe里的window对象，但该window对象的属性和方法几乎是不可用的
        var doc = win.document;//这里获取不到iframe里的document对象
        var name = win.name;//这里同样获取不到window对象的name属性
    }
</script>
<iframe id = "iframe" src="http://example.com/b.html" onload = "test()"></iframe>

这个时候，document.domain就可以派上用场了，我们只要把http://www.example.com/a.html 和 http://example.com/b.html这两个页面的document.domain都设成相同的域名就可以了。
1.在页面 http://www.example.com/a.html 中设置document.domain:

<iframe id = "iframe" src="http://example.com/b.html" onload = "test()"></iframe>
<script type="text/javascript">
    document.domain = 'example.com';//设置成主域
    function test(){
        alert(document.getElementById('iframe').contentWindow);//contentWindow 可取得子窗口的 window 对象
    }
</script>

2.在页面 http://example.com/b.html 中也设置document.domain:

<script type="text/javascript">
    document.domain = 'example.com';//在iframe载入这个页面也设置document.domain，使之与主页面的document.domain相同
</script>

５、window.name
关键点：window.name在页面的生命周期里共享一个window.name;
兼容性：所有浏览器都支持；
优点：
　最简单的利用了浏览器的特性来做到不同域之间的数据传递；
　不需要前端和后端的特殊配制；
缺点：
　大小限制：window.name最大size是2M左右，不同浏览器中会有不同约定；
　安全性：当前页面所有window都可以修改，很不安全；
　数据类型：传递数据只能限于字符串，如果是对象或者其他会自动被转化为字符串，如下；

使用方式：修改window.name的值即可；
６、postMessage
关键点：
　postMessage是h5引入的一个新概念，现在也在进一步的推广和发展中，他进行了一系列的封装，我们可以通过window.postMessage的方式进行使用，并可以监听其发送的消息；
兼容性：移动端可以放心用，但是pc端需要做降级处理
优点
　不需要后端介入就可以做到跨域，一个函数外加两个参数（请求url，发送数据）就可以搞定；
　移动端兼容性好；
缺点
　无法做到一对一的传递方式：监听中需要做很多消息的识别，由于postMessage发出的消息对于同一个页面的不同功能相当于一个广播的过程，该页面的所有onmessage都会收到，所以需要做消息的判断；
安全性问题：三方可以通过截获，注入html或者脚本的形式监听到消息，从而能够做到篡改的效果，所以在postMessage和onmessage中一定要做好这方面的限制；
　发送的数据会通过结构化克隆算法进行序列化，所以只有满足该算法要求的参数才能够被解析，否则会报错，如function就不能当作参数进行传递；
使用方式：通信的函数，sendMessage负责发送消息，bindEvent负责消息的监听并处理，可以通过代码来做一个大致了解；

Storage.prototype.sendMessage_ = function(type, params, fn) {
    if (this.topWindow) {
        this.handleCookie_(type, params, fn);
        return;
    }
    var eventId = this.addToQueue_(fn, type);
    var storageIframe = document.getElementById('mip-storage-iframe');
    var element = document.createElement("a");
    element.href = this.origin;
    var origin = element.href.slice(0, element.href.indexOf(element.pathname) + 1);
    storageIframe.contentWindow.postMessage({
        type: type,
        params: params,
        eventId: eventId
    }, origin);
}
Storage.prototype.bindEvent_ = function() {
    window.onmessage = function (res) {
        // 判断消息来源
        if (window == res.source.window.parent &&
            res.data.type === this.messageType.RES &&
            window.location.href.match(res.origin.host).length > 0) {
            var fn = this.eventQueue[res.data.eventId];
            fn && fn();
            delete this.eventQueue[res.data.eventId];
            // reset id
            var isEmpty = true;
            for (var t in this.eventQueue) {
                isEmpty = false;
            }
            if (isEmpty) {
                this.id = 0;
            }
        }
    }.bind(this);
}

以下内容来源: 小师弟
文章作者: 小师弟
文章链接: https://www.liuyao-blog.cn/posts/d9d7.html
本文章著作权归作者所有，任何形式的转载都请注明出处。

搞学习

CSDN： https://www.csdn.net/

TED（最优质的演讲）：https://www.ted.com/

谷粉学术： https://gfsoso.99lb.net/scholar.html

大学资源网：http://www.dxzy163.com/

简答题：http://www.jiandati.com/

网易公开课：https://open.163.com/ted/

网易云课堂：https://study.163.com/

中国大学MOOC：https://www.icourse163.org

哔哩哔哩弹幕网： https://www.bilibili.com

我要自学网： https://www.51zxw.net

知乎：https://www.zhihu.com

学堂在线：www.xuetangx.com

爱课程：https://www.icourses.cn

猫咪论文：https://lunwen.im/

iData（论文搜索）：https://www.cn-ki.net

文泉考试：https://www.wqkaoshi.com

嵌入式

51黑： http://www.51hei.com/bbs/

YRRoBot：http://yfrobot.com/forum.php

STMCU: https://www.stmcu.com.cn/

野火电子：http://www.firebbs.cn/forum.php?mod=guide

正点原子：http://www.openedv.com/forum.php

安富莱电子：http://www.armbbs.cn/forum.php