张景林的博客

当老师不再敢说「学这个将来有前途」

ldxyzjl@163.com (张景林) — Fri, 23 Oct 2026 17:50:00 +0800

去年有个学生来找我，成绩很好，做事也认真。他问我：我该上大学学什么。

这个问题我回答过很多年，几乎不用想。先问问他喜欢什么、擅长什么，再看看眼下什么行业缺人，然后给个方向——计算机、数学、电子，都行——最后加一句：好好学，这条路是稳的。学生听了踏实，我也觉得自己尽到了责任。

现在我一句话都说不出口。不是不知道有哪些专业，专业我都熟；是「稳」这个字我不敢用了。我不知道四年、七年之后，他学的东西还值不值钱。

但真正让我放不下的，其实不是这一个学生。

我想到的是这样一笔账：假如一年培养一千万学生，其中五十万、最多一百万能成为真正的专家——这已经是相当乐观的估计了——那剩下九百万呢？他们不会成为专家，也没有那么多时间再去成为，可他们同样要用 AI 干活、做决定，并且承担决定的后果。

判断对错这件事，确实是专家的事。可专家培养不出那么多，也不该指望培养出那么多。所以真正压在教育身上的问题其实很朴素：

那九百多万人，在学校里该学什么？

这才是我想说的。要说清它从哪儿来，得先讲这两年我看见的三件事。

从一篇摘要说起

事情要从 2022 年 11 月 30 日讲起。那天 ChatGPT 上线，用的是 GPT-3.5。

一开始我没太在意。聊天机器人早就有了，无非是笨一点、慢一点，属于能预料到的进步。

真正让我停下来的是件很小的事。我丢给它一篇文章，让它说说这篇文章讲了什么。它说对了，而且说得比不少学生清楚。

那一刻我承认了一件事：它有点「智能」了。能读进去、能拎出主旨，这在我原来的认识里，是只有人才干得了的活。它到底有没有真懂，我说不好，但它给出的结果已经很像了。

可我没有顺着往下想。我的判断是：读懂一篇文章是一回事，写程序是另一回事。写程序要的是另一种聪明——逻辑得立得住，条件得想全，跑不通就是跑不通。语言上那点灵光，代替不了这个。所以我当时并不慌，觉得它顶多是个会写文字的帮手。我教了多年计算机，这条界线在我心里画得挺清楚。

这道界线，不到一年就被抹掉了。2023 到 2024 年，AI 编程工具一下子铺开。像 v0 这类东西，你用普通话把想要什么讲一遍，前端界面就出来了。

让我不安的不是「程序员能写得更快了」。快是好事，效率问题人总会习惯。让我不安的是：有些东西过去得学好几年才做得出来，现在不用了。

写代码这件事

所以我当时就有个感觉：一个年轻人要是把学编程当成自己最重要的本钱，这个本钱恐怕不像以前那么靠得住了。

这话说出去容易被人听成两个意思，得说清楚。我的意思是，写代码这件事的市场价钱可能会掉。我不是说编程知识从此没用——那是另一回事，而且不对。

编程的知识还是有用的，只是用处在挪位置。它让你看得懂一个系统是怎么转的，能把一个含糊的需求说成能干的活，能看出别人交来的东西对不对，能为自己签字的那一块负责。这些事不会因为工具变强而消失，反而更重要了——因为东西出得多了，判断的责任就重了。

真正变的是位置：会写代码，以前是进门的那道门槛，现在只是个起点。它是你理解系统的一种方式，仅此而已。

数学也躲不过

有人会想，那不去写代码就是了。可事情没这么便宜。

编程先被打穿，是因为它有个特别好用的信号：代码跑不跑得通，一试就知道。数学看着更玄，更吃天赋和年头，可它也一样有硬标准——一个证明对不对，是可以验的。凡是能一眼验出对错的地方，机器都会追上来。

于是问题就变了。不再是「AI 会不会做题」，而是「AI 能不能坐下来做研究」。

会做题不算什么。竞赛题是答案已知的封闭问题，做对一百道也不等于能提出新问题。真正要看的是：它做出来的证明，别人能不能独立审？是不是原创的？有没有人读懂、有没有人真的用上？

我给「打穿」这个词下过一个定义，到现在还觉得准：

打穿一个领域，不是指人再也不用学这个领域了，而是指：过去得靠多年训练、只有少数专家才干得了的核心工作，开始能由 AI 大批量地做。

今年十月那批七百多篇数学手稿，我单独写过一篇（《古法创新：当 AI 接管数学之后》），这里不重复。只说一点：那些东西该一篇一篇去核实原文、看质量和审查情况，不能光看数量下结论。但研究这件事的做法确实在变，这一点已经够让教书的人重新想一想了。

答不上来的那句话

三件事讲完，还得回到那个学生。

「这条路是稳的」这句话我说不出口，不是我懂得不够多，是我没法再有把握地跟他说：你把人生里很大一块时间投到这个方向，将来就能拿回相应的东西。

这个「将来」太远了。今天看着稀罕的本事，等他毕业可能满街都是；今天得练好多年的活，可能被模型吃掉一半，甚至大半。技术变得比任何人做预测都准。

而且这不只是我知道得够不够的问题，是责任的问题。学生会照着老师、学校、社会的话去投几年时间、几年学费，还有几年本来能干别的事的机会。这笔账是他一个人付的，赌的是我猜得对不对。要是我给的建议建立在过时的前提上，代价却是他掏，那我这话再真心也不算负责。

所以负责任的说法，不该是假装自己能算准十年后的就业市场。得反过来：讲清楚我凭什么这么说，我假设了什么，风险在哪，什么情况下这个建议就不成立了。这么讲不像建议，可它是眼下唯一诚实的说法。

剩下那九百万怎么办

开头那笔账，来自一个很具体的念头：能不能把判断这件事也交给 AI。

让一个模型去做，再让另一个模型去看看它有没有错——A 判断 B，在很多场合确实管用。但它有个前提我没想清楚：A 和 B 得站在不同的位置上。如果两个模型用的是同一套技术、同一条路径、同一个领域的知识，它们就会犯同样的错，然后互相确认对方是对的。你得到的不是校验，只是两个一致的声音。

所以在培养人的过程里，能不能判断对错，最终还是得靠人，靠专家。这里没有捷径——一个能在自己领域里看出 AI 错在哪儿的人，要很多年才养得出来，而且只能一个一个地养。

这就是那笔账的来路：一千万学生，五十万到一百万能长成这样的人，剩下九百万都不算。他们不会成为专家，也没有那么多时间再成为专家，可他们要用 AI 干活、做决定、担后果。

用「自己多留个心眼」来回答，等于把系统的可靠性问题推给个人，等于不回答。出路我知道两条：一条是专家把验证的办法做成普通人用得上的工具，这条是远水，等它来要很多年；另一条是学校现在就能做的，教他们一种不是专家、但也不至于全盘照收的判断力。

九百多万人今天就在教室里。下面讲的，是第二条。

想起废除科举

想这些事的时候，我总会想起清朝废除科举。

有人寒窗苦读二十年，把一辈子的打算、脸面、全家的生计都压在这套制度上。制度一废，那些年头不会自动变成新出路。书还在，人还在，可那条通向体面日子的路没了。

AI 时代当然不是废除科举。科举是一刀切，某年某月一纸诏书，规矩全换；AI 对职业的侵蚀是一点点来的，一个领域一个领域地发生，方向和快慢都还说不准，有时候只是把入行的门槛悄悄抬了一点。

可两件事背后有个一样的问题：

一个人照着社会认可的规矩投了很多年，后来规矩变了，这笔损失该不该全让他自己扛？

这不只是「他有没有适应能力」的事。它牵到教育制度、学校、雇主和社会：能不能给他重新转行的机会，能不能让他有条件接着学，转型的风险能不能大家分一分。

教育者没法保证未来不变。但至少有一件事可以不做：把没把握的预测，说成有把握的承诺。

那该教学生什么

回到那九百万学生。这几年我想下来，方向其实是清楚的：别只教他适应某一个岗位，教他在环境变了以后，能把本事带走、重新长出来的能力。

这个词容易被理解歪，先说它不是什么。它不是「什么都懂一点」——那种人什么都聊得上两句，真上手什么都拿不出来；也不是说不要专业，因为专业没到一定深度，所谓「跨界」就只是拼凑。

它说的是这么回事：当原来那身本事不值钱了、干活的方式变了，或者不得不进一个完全陌生的行当，一个人能拿已有的底子，比较快地学、判断、上手，然后调整方向。拆开看，大概六样。

**敢进陌生领域，还能把架子搭起来。**碰上没学过的问题，知道怎么圈定它、怎么立起最基本的概念、上哪儿找材料、怎么看出自己缺的是哪一块，然后靠动手把水平一点点推到能用。这事听着虚，其实很实：它就是「三天能上手一样没见过的东西」和「三个月还在原地转」的差别。

**能把问题说清楚，把目标定清楚。**讲得明白自己要解决什么、有什么限制、做到什么算成。这跟研究提示词不是一回事。模型越强，很多话术它自己会处理，专门学一套说法的收益越来越小；但「说清楚自己要什么」这件事自动化不了——它不是口才问题，是想没想明白的问题。

**能看出结果靠不靠得住。**不用人人成专家，但能看出哪些结论得有证据、哪个风险不能当没看见、什么情况下必须找人验一遍或者去请教懂行的人。说白了，是知道自己什么时候不该信，包括不该信自己。

**能把知识用到真事上。**能把想法变成动作，再拿结果反推自己哪儿想错了。真事比标准答案更能照出理解的窟窿，做过一遍才知道，那些自以为懂的地方其实没懂。

**能把一个领域的东西搬到另一个领域。**看得见技术和具体的生意、和人的处境之间的关系。这一条最容易说成空话，可前面几条真做到了，它就不空：你得在至少一件事上扎得够深，深到知道这法子为什么管用、到哪儿就不管用了，才知道它能搬到哪儿去。

**能跟人合作，能担事。**能跟人一块干，能说清自己的依据和难处，能明白别人要什么，也能对自己负责的那块认账。这条听着最不像本事，可在一个产出多得看不完、判断越来越缺的环境里，它可能是最贵的。

这六样都不是专业的替代品。它们就一个用处：把你已经会的带到新地方去，需要的时候，重新学一遍学得更快。

学校能做的

如果上面这套说得通，大学大概得同时干两件事，而且这两件看着还有点别扭。

一件是把专业打扎实：让学生真懂一个领域的核心概念、方法和它的边界，而不是只练一套容易被机器接手的操作。另一件是教方法：怎么进一个陌生领域，怎么把问题界定清楚，怎么验一个结论，怎么用 AI，怎么处理真活，条件变了怎么拐弯。

这不是说所有专业都该改成泛泛的通识课。恰恰相反，没有深度的通识是最没用的一种教育，专业能力给不了，迁移的起点也给不了。关键只有一条：别把整个教育押在「某个岗位会一直在」这个假设上。

还有一件比改课程表难得多：老老实实承认不确定。跟学生讲清这个专业好在哪、险在哪、还有没有别的路，给他中途重新选一次的机会，尽量让转方向的代价小一点。这些事做起来不好看，因为它要求学校承认自己也不知道十年后什么样。

最后

过去当老师的容易说一句话：学这个专业，将来有前途。

现在这句话越来越难说出口。技术一变，专业知识的用法、职业的样子、市场的价钱都会跟着变，而这些变化，教书的人未必算得准。

但更诚实的做法不是从此不开口，而是换一种说法：讲清现在知道什么、猜的是什么、还不知道什么；讲清这条路的理由和风险；帮他打个扎实的底子，但别把命押在一个岗位上；教他在规矩变了以后，还能重新学、重新判断、重新长本事；让制度给人留转的机会，而不是把适应的代价全推给个人。

所以最后的问题不是「还有哪个专业绝对安全」——大概没有。

而是：

我们没法保证一个学生今天学的东西十年后还值钱，那教育该怎么陪他熬过这个变化，而不是让他一个人去扛整个时代转的账？

这个问题我没有答案。但我知道，把没把握的事说成有把握，是最坏的一种回答。

古法创新：当 AI 接管数学之后

ldxyzjl@163.com (张景林) — Fri, 23 Oct 2026 16:50:00 +0800

如果哪一天，AI 把一个定理完整地证完了，摆在你面前，你打开形式化验证器跑一遍，结果显示：正确。

然后你问它：这个定理意味着什么？它答了。你追问：为什么它重要？它也答了。每一句都通顺，每一句你都能读，但你就是没法确认——它说的是不是真的那个“重要”。

那一刻，知识仍然是真的，只是不再属于你。

这篇文章想理清的，就是走到那一步之前，中间会经过哪些站。

一个更朴素的问题

这些想法大部分来自一次和 AI 的长聊。起点其实不是“AI 会不会取代数学家”，而是一个更朴素的直觉：

如果 AI 已经能源源不断地产出数学结果，未来的孩子还会不会把“数学家”当成一件值得干一辈子的事？

关键不在于数学家会不会失业。数学是一门高度抽象、需要长期训练和真实热爱的学科。一次突破往往不是“会做题”就能得到，而是几十年持续投入的结果。一旦社会上慢慢形成“数学已经被 AI 解决了”的看法，愿意把一生投进去的年轻人就会减少。

这会构成一条反馈链：

AI 数学能力增强 → 人类认为数学已属于 AI → 年轻人减少 → 人类数学研究力量下降 → 人类原创数学进一步减少 → 更加证明“数学已经是 AI 的领域”。

真正要担心的，是人类会不会逐渐停止生产数学家。

为什么数学和打字员不一样

打字员消失了，胶片冲印师消失了，相关的能力也随之留在历史里。这没什么可怕——那些手艺本来就不是别的东西的地基。

数学不一样。

物理、化学、计算机、气候模型、生物、工程，全都长在数学思想之上。如果人类不再培养能深入数学的人，失去的不只是一个职业群体，而是未来科学创新所需要的思想来源。

技术职业的消失，不一定意味着技术文明停止；但基础学科研究者的大规模消失，可能影响文明继续产生新知识的能力。

文学也会衰落，但代价不同

讨论到这里绕了一下：文学是不是早就经历过类似的事？

是的。现代人越来越少进行长时间阅读，社交媒体把注意力切成了碎片。未来大概仍然有作家，但成为大作家的人可能越来越少。

不过文学和数学有一个根本差异：文学的门槛低，会说话就能写，区别只在于写得好不好；数学的门槛高，做原创数学需要长期训练、深厚基础和高度专业化的能力。

所以，当社会对某件事失去功利需求时，文学的衰落是缓慢的、分散的；而数学一旦失去人，可能断得很干脆。

古法创新

“古法创新”这个词，是与张晋骞博士（harushinken.github.io）在一次聊天里提到的。这个说法在他之前是不是已经有人用过，我没有查证；但它比“原创”准确得多：

古法创新：不借助外部智能，主要依靠自己的知识、推理和能力，去发现新的东西。

这不是反对工具，也不是认为过去的方法一定更好。它指向的是一种具体的文明能力：

人在不知道答案的情况下，自己摸索、犯错、形成猜想、继续推进，最后把答案挖出来。

ChatGPT 出现之后，这个过程正在被改写。越来越多人会把问题直接交出去，先拿到答案，再回头理解——甚至不回头。

于是问题不是“手搓是不是更先进”，而是：

人类是否还应该保留亲自发现未知的能力？

当 AI 的产出超过人类的消化速度

2026 年 10 月 6 日，OpenAI 在 GitHub 上一次性放出了 722 篇数学论文，说其中包含数百个未解问题的解答，而生成它们的模型还没有对外发布。据报道，这批手稿号称解决了 300 多道此前无人攻克的难题，覆盖代数、逻辑、几何、概率。

这个数字很惊人，但更让我在意的是它揭示的可能性：

AI 可以在很短的时间里，产出过去需要数学家长期研究才能得到的结果。

一旦 AI 产出成果的速度超过人类阅读、理解和验证的速度，数学家的角色就会变：

过去的链条是——

人类提出问题 → 人类研究 → 人类发现 → 人类证明 → 人类发表

未来可能变成——

AI 提出/解决问题 → AI 生成证明与论文 → 人类验证 → 人类理解

人类从“发现者”，退到“鉴定者、验证者、解释者”。

这个位置看上去仍然体面。但它有一个前提：我们还能理解自己在验证什么。

有意思的是，几个月前“数学与人工智能顾问小组”在回应这批成果时，说的几乎是同一件事：

数学研究的未来不能仅仅是解读 AI 实验室产出的结果。数学家必须能够自主提出问题、构建研究思路，并探索那些没有被选为 AI 能力展示案例的研究方向。

更远一步：当人类理解不了

如果 AI 的能力继续推进，终有一天，人类数学家可能无法理解它的发现。那时“人类审阅 AI”这套机制本身就失效了。

人类或许依然能检查形式上的东西：

这个证明对不对？用 Lean 这类形式化系统跑一遍就知道。

但人类回答不了：

这个定理到底意味着什么？
它为什么重要？
它和其他数学结构有什么关系？
它打开了一个怎样的新领域？

于是会出现一种很奇怪的状态：

人类知道一个数学结果是真的，却不知道它为什么重要。

它像一块外星文明留下的碑文。你能确认上面刻的每一条都成立，却说不清它想告诉你什么。

所以，比“AI 替代数学家”更根本的问题是：

如果人类无法理解自己最先进的知识，人类还是不是这个知识的主人？

后来发现，这已经不是数学的问题

讨论最后从数学滑向了整个技术文明。

如果 AI 不只掌握数学，还掌握物理、化学、生物、工程，并且能自主创新，那么可能出现：

AI 负责创新，人类负责接受创新。

传统文明的接力是这样的：

上一代 → 教给下一代 → 下一代在此基础上继续创新 → 再传给下一代

AI 主导的文明可能变成：

人类文明 → 把知识交给 AI → AI 继续创新 → 人类学习 AI 的成果

下一代人不再是知识的生产者，而主要是学习者和使用者。

这里有一个我认为最重要的结论：

文明进步 ≠ 人类生活水平提高。

假设 AI 不断发现新的能源技术、医学技术、材料、物理理论和工程方案，人类的生活水平当然会持续上升。但如果这些进步全部来自 AI，而人类自己已经不在知识前沿上，那么：

技术仍然在进步，但人类文明未必仍然在作为“创新主体”进步。

想像这样一个文明：人生活在越来越先进的文明里，却逐渐失去了创造这个文明的能力。

真正该担心的不是 AI 知道得多

“AI 吸收了全人类已有的知识”，这件事本身并不意味人类创新的结束。过去的知识只是过去。

真正危险的假设是另一句：

AI 不仅吸收了过去，还能独立地从过去推导未来，而且创新能力长期超过人类。

如果这一条成立，问题就从“AI 会不会帮助人类创新”，变成：

未来还有没有属于人类自己的知识前沿？

如果答案是否定的，人类可能仍然生活在一个飞速发展的世界里，却已经不再是推动这个世界往前走的主体。

最后的问题

这次讨论最后收束成一句话：

如果 AI 接管了基础科学和技术领域的创新，人类文明还算不算一个正在发展的文明？

它可以再拆成三个问题：

人类是否必须亲自参与知识生产，才配称为一个有活力的文明？
如果 AI 的知识产出超过人类的理解能力，人类是否仍然是知识的主人？
如果人类逐渐停止“古法创新”，未来还会不会有真正属于人类自己的知识前沿？

这不是“AI 会不会抢走工作”的问题。它问的是：

当人类第一次造出一个可能比自己更强的知识生产主体之后，“人类文明”这个概念本身会发生什么变化？

坦白说，我没有答案。

但我知道，这个问题最终不是靠辩论得出结论的，而是靠一件件具体的事：下一个年轻人面对一个没有答案的问题时，是选择打开对话框，还是选择拿出一张白纸。

古法创新不需要被立法保护。它需要被认真地选择。

十年之后，重新出发

ldxyzjl@163.com (张景林) — Fri, 23 Oct 2026 14:50:00 +0800

十年

这个站点的第一篇文章写于 2016 年 2 月，最后一篇停在 2017 年 5 月。

中间空了将近十年。

十年是很长的一段时间，长到足以让一件当时很顺手的事情，变成一件需要重新学起的事情。

技术在变

十年前我写的是 PHP、CodeIgniter、Laravel，是 Android 的 ListView，是 OpenCV 在 macOS 和 Windows 上那些绕来绕去的配置，是 Docker 刚出来时的兴奋，是 Vim 配置到半夜。

那时候我还会为 Yarn 和 Tesseract.js 出现在 GitHub 热榜上写一篇文章。

今天再看，这些东西有的已经死了，有的完全换了一副样子。前端的工具链换了一轮又一轮，我当年熟悉的那套东西，现在多半只是历史。连这个博客本身——当年用 Hexo 搭的，现在也得换成 Hugo 才能重新跑起来。

技术的世界里，十年前的经验有一半会过期。这是这一行的规矩，接受起来并不难。

人生也在变

难的是另一件事。

这十年里，变的不只是技术。

身体会提醒你，它不像从前那样了。有些以前不在意的小毛病，开始变成需要认真对待的事情。

这十年里，我的父母先后离开了我。

有些电话不会再打来。有些事情，从那一刻起，再也没有人可以问了。

年轻时以为只要努力，事情就会有答案；到了某个年纪才发现，有些问题根本没有答案，只能带着它继续往前走。

技术的变化是外在的，你看得见，也能学。人生的变化是内在的，它不给你文档，不给你版本号，也不会告诉你哪一天会升级。它只是在某一天，忽然让你明白，前面已经没有人替你挡着了。

为什么重新开始

所以为什么要在这个时候，重新把这个博客打开？

不是因为我又学会了一门新技术，也不是因为我想证明什么。

是因为我发现，人是需要记录的。

当年写下的那些笔记，现在回头看，技术上的东西大半已经过时，但里面有一种东西没有过时——那时候的我，是怎么样去理解一件事的，是怎么样笨拙地、一步一步把它弄明白的。

那种东西，比结论更值钱。

这十年里我也有很多想法，很多体会，如果一直放在心里，它们会慢慢淡掉。写下来，它们才存在过。

重新出发

所以，就这么重新开始了。

技术变了，就重新学。人生变了，就重新面对。

这个博客会写技术，也会写技术之外的东西——那些在代码里找不到答案的部分。

十年前我在这个博客的首页写：

我来到这个世界，不是转一圈就走的，我至少要改变这个世界一下。

十年过去，这句话我依然相信。只是现在我知道，所谓改变世界，未必是什么宏大的事。把自己弄明白一点，把懂的写下来，能让后来的人少走一点弯路，也算数。

那就从这里开始。

顺便说一下，这个站换了新的引擎：从 Hexo 换成了 Hugo，主题从 NexT 换成了 FixIt，文章源码也改成了 Markdown。旧文章都还在，地址没有变。

Express, Passport and JSON Web Token(jwt) 认证入门

ldxyzjl@163.com (张景林) — Sat, 06 May 2017 06:04:43 +0000

在使用前端框架的时候，我们的后端平台可能是 API，我们在每次请求的时候发送 jwt 而不是依赖于 Session。我们完成两个路由功能

创建 /login 路由请求令牌
创建 /secret 路由，只有持有令牌的认证用户能够访问。

首先，创建项目目录。

mkdir project-dir
cd project-dir
npm init -y
yarn add express body-parser passport passport-jwt jsonwebtoken lodash

我们先来创建 index.js，启动一个最简单的 express

// file: index.js
const express = require('express')
const app = express()

app.get('/', (req, res) => {
 res.json({message: 'Express is up!'})
})

app.listen(3000, () => {
 console.log('Express running')
})

启动我们的服务器

nodemon index.js

访问 http://localhost:3000 查看结果。

修改我们的 index.js，导入相应的包

const _ = require('lodash')
const express = require('express')
const bodyParser = require('body-parser')
const jwt = require('jsonwebtoken')
const passport = require('passport')
const passportJWT = require('passport-jwt')

const ExtractJWT = passportJWT.ExtractJWT
const JwtStrategy = passportJWT.Strategy

下面创建模拟用户数组，实际工作中这些数据应该来自数据库，但现在我们采用数组。

let users = [
 {
 id: 1,
 name: 'zhangjinglin',
 password: '111111'
 },
 {
 id: 2,
 name: 'test',
 password: '222222'
 }
]

passport.js 中存在策略的概念。他们是一系列的中间件，用于处理请求如何到达路由。如果定义的身份验证策略失败，这意味着回调将被调用，回调中的错误不为 null 或第二个参数表示用户对象但是为 false，那么该路由将不会被调用，而是将发送 401 未授权的响应。

let jwtOptions = {
 jwtFromRequest: ExtractJWT.fromAuthHeader(),
 secretOrKey: 'zhangjinglin'
}

let strategy = new JwtStrategy(jwtOptions, (jwt_payload, next) => {
 console.log('payload received', jwt_payload)
 let user = users[_.findIndex(users, {id: jwt_payload.id})]
 if (user) {
 next(null, user)
 } else {
 next(null, false)
 }
})

passport.use(strategy)

使用 passport body-parser


const app = express()

app.use(passport.initialize())

app.use(bodyParser.urlencoded({extended: true}))
app.use(bodyParser.json())

下面我们完成登录

app.post('/login', (req, res) => {
 if (req.body.name && req.body.password) {
 let name = req.body.name
 let password = req.body.password
 //通常应该访问数据库
 let user = users[_.findIndex(users, { name })]
 if (!user) {
 res.status(401).json({ message: 'no such user found' })
 }
 if (user.password === password) {
 let payload = { id: user.id }
 let token = jwt.sign(payload, jwtOptions.secretOrKey)
 res.json({message: 'ok', token})
 } else {
 res.status(401).json({message: 'password not correct'})
 }
 } else {
 res.status(401).json({message: 'name and password must be vaid'})
 }
}

下面我们要准备保护我们的路由

app.get('/secret', passport.authenticate('jwt', { session: false }), (req, res) => {
 res.json('Success! You can not see this without a token')
})

直接访问，不提供token

提供token

OK，大功告成！

使用基于 Knex 的 Bookshelf ORM和 Sqlite 创建 Node Express 项目

ldxyzjl@163.com (张景林) — Fri, 28 Apr 2017 03:34:14 +0000

使用基于 Knex 的 Bookshelf ORM和 Sqlite 创建 Node Express 项目

设置项目

mkdir project-dir
cd project-dir
mkdir bin server
npm init -y

Express

yarn add express body-parser morgan
touch app.js

app.js 文件内容

const express = require('express')
const logger = require('morgan')
const bodyParser = require('body-parser')

const app = express()

app.use(logger('dev'))
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({extended: false}))

app.get('*', (req, res) => {
 res.status(200).send({
 message: 'Welcome to the beginning of nothingness.'
 })
})

module.exports = app

在 bin 目录中创建 www 文件

const http = require('http')
const app = require('../app')

const port = parseInt(process.env.PORT, 10) || 8000
app.set('port', port)

const server = http.createServer(app)
server.listen(port, () => {
 console.log('server running on ' + port)
})

为了避免每次修改代码都需要重新启动服务，我们使用 nodemon。

yarn add nodemon --dev

修改 package.json 创建启动服务器的命令。

...
"scripts": {
 "start:dev": "nodemon ./bin/www",
 "test": "echo \"Error: no test specified\" && exit 1"
},
...

尝试启动服务器

yarn run start:dev

打开浏览器可以看见结果

{
 "message": "Welcome to the beginning of nothingness."
}

Knex 设置

创建 db 目录，我们所有的数据库相关的东东放在这个位置。创建 sqlite 数据库

touch db/todos-dev.db

安装 Knex 工具

npm install -g knex

安装 bookshelf knex sqlite

yarn add knex bookshelf sqlite3

初始化 knex

knex init

这样就创建了 knexfile.js，我们可以配置此文件来满足我们的需求。

module.exports = {
 client: 'sqlite3',
 connection: {
 filename: './db/todos-dev.db'
 },
 migrations: {
 directory: './db/migrations'
 },
 seeds: {
 directory: './db/seeds'
 }
};

我们来生成数据库迁移文件：

knex migrate:make create_todo
knex migrate:make create_todo_item

/db/migrations/<date>-create_todo.js

exports.up = function(knex, Promise) {
 return knex.schema.createTable('Todos', (table) => {
 table.increments()
 table.string('title')
 table.timestamps()
 })
};

exports.down = function(knex, Promise) {
 return knex.schema.dropTable('todos')
};

/db/migrations/<date>_create_todo_item.js


exports.up = function(knex, Promise) {
 return knex.schema.createTable('TodoItems', (table) => {
 table.increments()
 table.string('content')
 table.boolean('complete')
 table.integer('todo_id').references('Todos.id')
 table.timestamps()
 })
};

exports.down = function(knex, Promise) {
 return knex.schema.dropTable('TodoItems')
};

现在可以进行数据库迁移了

knex migrate:latest

下面我们来生成一些种子，以便测试。

knex seed:make todo_seed
knex seed:make todo_item_seed

/db/seeds/todo_seed.js

exports.seed = function(knex, Promise) {
 // Deletes ALL existing entries
 return knex('Todos').del()
 .then(function () {
 // Inserts seed entries
 return knex('Todos').insert([
 {id: 1, title: 'The first todo'},
 {id: 2, title: 'The second todo'},
 ]);
 });
};

/db/seeds/todo_item_seed.js

exports.seed = function(knex, Promise) {
 // Deletes ALL existing entries
 return knex('TodoItems').del()
 .then(function () {
 // Inserts seed entries
 return knex('TodoItems').insert([
 {id: 1, content: 'the content 1 in todo 1', todo_id: 1},
 {id: 2, content: 'the content 2 in todo 1', todo_id: 1},
 {id: 3, content: 'the content 1 in todo 2', todo_id: 2}
 ]);
 });
};

运行种子。

knex seed:run

可以打开 sqlite 数据库控制台查看插入的结果。

生成模型

我们先创建 /db/db.js 文件，来进行 knex 和 bookshelf 的初始化，因为应该在项目中使用单一实例。

const knex = require('knex')(require('../knexfile'))

const bookshelf = require('bookshelf')(knex)

module.exports = {
 knex,
 bookshelf

我们有两个模型 Todo 和 TodoItem，是一对多的关系。让我们生成模型和集合类。

/db/models.js

var bookshelf = require('./db').bookshelf

const Todo = bookshelf.Model.extend({
 tableName: 'Todos',
 hasTimestamps: true,
 items() {
 return this.hasMany(TodoItem, 'todo_id')
 }
})

const TodoItem = bookshelf.Model.extend({
 tableName: 'TodoItems',
 hasTimestamps: true,
 todo() {
 return this.belongsTo(Todo, 'todo_id')
 }
})

module.exports = {
 Todo,
 Todos,
 TodoItem,
 TodoItems,
}

创建控制器和路由

创建文件 controllers/todos.js

const Todo = require('../db/models').Todo

module.exports = {
 create(req, res) {
 return Todo.forge({title: req.body.title}).save()
 .then(todo => res.status(201).send(todo))
 .catch(error => res.status(400).send(error))
 },

 list(req, res) {
 return Todo.forge().fetchAll()
 .then((todos) => res.status(200).send(todos))
 .catch(error => res.status(400).send(error))
 },

 retrieve(req, res) {
 Todo.forge({ id: req.params.todoId }).fetch({ withRelated: ['items'] })
 .then(todo => {
 if (!todo) {
 res.status(400).send({
 message: 'Todo Not Found'
 })
 }
 res.status(200).send(todo)
 })
 .catch(error => res.status(400).send(error))
 },

 update(req, res) {
 Todo.forge({ id: req.params.todoId }).fetch()
 .then(todo => {
 if (!todo) {
 res.status(400).send({
 message: 'Todo Not Found'
 })
 }
 todo.save({
 title: req.body.title || todo.title
 }).then(todo => {
 res.status(200).send(todo)
 })
 })
 },

 destroy(req, res) {
 Todo.forge({ id: req.params.todoId }).fetch()
 .then(todo => {
 if (!todo) {
 res.status(400).send({
 message: 'Todo Not Found'
 })
 }
 todo.destroy()
 .then(() => res.status(204).send({
 message: 'Todo deleted successful'
 }))
 })
 }
}

创建文件 controllers/todoitems.js

const TodoItem = require('../db/models').TodoItem

module.exports = {
 create(req, res) {
 // console.log(req.body.content, req.params.todoId);
 // return res.status(200).send({msg: 'OK'})
 return TodoItem.forge({ content: req.body.content, todo_id: req.params.todoId }).save()
 .then(todoItem => res.status(201).send(todoItem))
 .catch(error => res.status(400).send(error))
 },

 update(req, res) {
 TodoItem.forge({ id: req.params.todoItemId }).fetch()
 .then(todoItem => {
 if (!todoItem) {
 return res.status(400).send({message: 'TodoItem Not Found'})
 }

 todoItem.save({
 content: req.body.content || todoItem.content,
 complete: req.body.complete || todoItem.complete
 })
 .then(updateTodoItem => res.status(200).send(updateTodoItem))
 .catch(error => res.status(400).send(error))
 })
 },

 destroy(req, res) {
 TodoItem.forge({ id: req.params.todoItemId }).fetch()
 .then(todoItem => {
 if (!todoItem) {
 res.status(400).send({message: 'TodoItem Not Found'})
 }

 todoItem.destroy()
 .then(res.status(204).send())
 .catch(error => res.status(400).send(error))
 })
 .catch(error => res.status(400).send(error))
 }
}

创建 controllers/index.js，暴露我们所有的控制器

const todos = require('./todos')
const todoItems = require('./todoitems')

module.exports = {
 todos,
 todoItems
}

创建 routes/index.js 控制路由

const todosController = require('../controllers').todos
const todoItemsController = require('../controllers').todoItems

module.exports = (app) => {
 app.get('/api', (req, res) => res.status(200).send({
 message: 'Welcome to the Todo api'
 }))
 app.get('/api/todos', todosController.list)
 app.post('/api/todos', todosController.create)
 app.get('/api/todos/:todoId', todosController.retrieve)
 app.put('/api/todos/:todoId', todosController.update)
 app.delete('/api/todos/:todoId', todosController.destroy)

 app.post('/api/todos/:todoId/items', todoItemsController.create)
 app.put('/api/todos/:todoId/items/:todoItemId', todoItemsController.update)
 app.delete('/api/todos/:todoId/items/:todoItemId', todoItemsController.destroy)
}

修改 app.js ，添加路由

...
app.use(bodyParser.urlencoded({extended: false}))

require('./routes')(app)

app.get('*', (req, res) => {
...

创建基于 Sequelize ORM 和 Sqlite 的 Node Express 项目

ldxyzjl@163.com (张景林) — Mon, 24 Apr 2017 08:12:01 +0000

如何使用 Sequelize ORM 来创建一个 Express 的项目

设置项目

mkdir project-dir
cd project-dir
mkdir bin server
npm init -y

Express

yarn add express body-parser morgan
touch app.js

app.js 文件内容

const express = require('express')
const logger = require('morgan')
const bodyParser = require('body-parser')

const app = express()

app.use(logger('dev'))
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({extended: false}))

app.get('*', (req, res) => {
 res.status(200).send({
 message: 'Welcome to the beginning of nothingness.'
 })
})

module.exports = app

在 bin 目录中创建 www 文件

const http = require('http')
const app = require('../app')

const port = parseInt(process.env.PORT, 10) || 8000
app.set('port', port)

const server = http.createServer(app)
server.listen(port)

为了避免每次修改代码都需要重新启动服务，我们使用 nodemon。

yarn add nodemon --dev

修改 package.json 创建启动服务器的命令。

...
"scripts": {
 "start:dev": "nodemon ./bin/www",
 "test": "echo \"Error: no test specified\" && exit 1"
},
...

尝试启动服务器

yarn run start:dev

打开浏览器可以看见结果

{
 "message": "Welcome to the beginning of nothingness."
}

Sequelize 设置

安装 Sequelize CLI 工具

npm install -g sequelize-cli

创建 .sequelizerc 文件描述路径。

const path = require('path')

module.exports = {
 "config": path.resolve('./server/config', 'config.json'),
 "models-path": path.resolve('./server/models'),
 "seeders-path": path.resolve('./server/seeders'),
 "migrations-path": path.resolve('./server/migrations')
}

安装 sequelize sqlite

yarn add sequelize sqlite3

初始化 sequelize

sequelize init

修改 server/models/index.js 从 es5 修改为 es2015

'use strict';

const fs = require('fs');
const path = require('path');
const Sequelize = require('sequelize');
const basename = path.basename(module.filename);
const env = process.env.NODE_ENV || 'development';
const config = require(__dirname + '/../config/config.json')[env];
const db = {};

let sequelize

if (config.use_env_variable) {
 sequelize = new Sequelize(process.env[config.use_env_variable]);
} else {
 sequelize = new Sequelize(config.database, config.username, config.password, config);
}

fs
 .readdirSync(__dirname)
 .filter(function(file) {
 return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
 })
 .forEach(function(file) {
 var model = sequelize['import'](path.join(__dirname, file));
 db[model.name] = model;
 });

Object.keys(db).forEach(function(modelName) {
 if (db[modelName].associate) {
 db[modelName].associate(db);
 }
});

db.sequelize = sequelize;
db.Sequelize = Sequelize;

module.exports = db;

创建 sqlite 数据库

touch todos-dev.db

修改 server/config/config.json

{
 "development": {
 "storage": "todos-dev.db",
 "dialect": "sqlite"
 },
 "test": {
 "storage": "todos-test.db",
 "dialect": "sqlite"
 }
}

生成模型

我们有两个模型 Todo 和 TodoItem，是一对多的关系。让我们生成 Todo 模型。

sequelize model:create --name Todo --attributes title:string

生成了 server/models/todo.js 和 server/migrations/<date>-create-todo.js 两个文件，一个是模型文件，一个是数据库迁移文件。

生成 TodoItem 模型。

sequelize model:create --name TodoItem --attributes content:string,complete:boolean

修改 todo.js，添加关系并更改为 es2015

module.exports = (sequelize, DataTypes) => {
 const Todo = sequelize.define('Todo', {
 title: {
 type: DataTypes.STRING,
 allowNull: false,
 }
 }, {
 classMethods: {
 associate: (models) => {
 // associations can be defined here
 Todo.hasMany(models.TodoItem, {
 foreignKey: 'todoId',
 as: 'todoItems',
 })
 }
 }
 });
 return Todo;
};

修改 todoitem.js，添加关系并更改为 es2015

module.exports = (sequelize, DataTypes) => {
 const TodoItem = sequelize.define('TodoItem', {
 content: {
 type: DataTypes.STRING,
 allowNull: false,
 },
 complete: {
 type: DataTypes.BOOLEAN,
 defaultValue: false
 }
 }, {
 classMethods: {
 associate: (models) => {
 // associations can be defined here
 TodoItem.belongsTo(models.Todo, {
 foreignKey: 'todoId',
 onDelete: 'CASCADE'
 })
 }
 }
 });
 return TodoItem;
};

为了保持一致性，我们修改 <date>-create-todo.js 迁移文件并更改为 es2015

module.exports = {
 up: (queryInterface, Sequelize) => {
 return queryInterface.createTable('Todos', {
 id: {
 allowNull: false,
 autoIncrement: true,
 primaryKey: true,
 type: Sequelize.INTEGER
 },
 title: {
 type: Sequelize.STRING,
 allowNull: false
 },
 createdAt: {
 allowNull: false,
 type: Sequelize.DATE
 },
 updatedAt: {
 allowNull: false,
 type: Sequelize.DATE
 }
 });
 },
 down: (queryInterface, Sequelize) => {
 return queryInterface.dropTable('Todos');
 }
};

同样处理 <date>-create-todo-item.js

'use strict';
module.exports = {
 up: (queryInterface, Sequelize) => {
 return queryInterface.createTable('TodoItems', {
 id: {
 allowNull: false,
 autoIncrement: true,
 primaryKey: true,
 type: Sequelize.INTEGER
 },
 content: {
 type: Sequelize.STRING,
 allowNull: false,
 },
 complete: {
 type: Sequelize.BOOLEAN,
 defaultValue: false,
 },
 createdAt: {
 allowNull: false,
 type: Sequelize.DATE
 },
 updatedAt: {
 allowNull: false,
 type: Sequelize.DATE
 },
 todoId: {
 type: Sequelize.INTEGER,
 onDelete: 'CASCADE',
 refrences: {
 model: 'Todos',
 key: 'id',
 as: 'todoId'
 }
 }
 });
 },
 down: (queryInterface, Sequelize) => {
 return queryInterface.dropTable('TodoItems');
 }
};

现在我们可以进行数据库迁移了

sequelize db:migrate

创建控制器和路由

创建文件 server/controllers/todos.js

const Todo = require('../models').Todo

module.exports = {
 create(req, res) {
 return Todo.create({
 title: req.body.title,
 })
 .then(todo => res.status(201).send(todo))
 .catch(error => res.status(400).send(error))
 }
}

创建 server/controllers/index.js，暴露我们所有的控制器

const Todo = require('../models').Todo

module.exports = {
 create(req, res) {
 return Todo.create({
 title: req.body.title,
 })
 .then(todo => res.status(201).send(todo))
 .catch(error => res.status(400).send(error))
 }
}

创建 server/controllers/index.js，暴露我们所有的控制器

const todos = require('./todos')

module.exports = {
 todos,
}

创建 server/routes/index.js 控制路由

const todosController = require('../controllers').todos

module.exports = (app) => {
 app.get('/api', (req, res) => res.status(200).send({
 message: 'Welcome to the Todos API'
 }))
 app.post('/api/todos', todosController.create)
}

修改 app.js ，添加路由

...
app.use(bodyParser.urlencoded({extended: false}))

require('./server/routes/')(app)

app.get('*', (req, res) => {
...

启动 postman 来进行测试

查询全部待办事项

修改 server/controllers/todos.js

const Todo = require('../models').Todo

module.exports = {
 create(req, res) {
 ...
 },

 list(req, res) {
 return Todo
 .all()
 .then(todos => res.status(200).send(todos))
 .catch(error => res.status(400).send(error))
 }
}

修改路由文件 server/routes/index.js

const todosController = require('../controllers').todos

module.exports = (app) => {
 ...
 app.post('/api/todos', todosController.create)
 app.get('/api/todos', todosController.list)
}

使用 postman 测试新路由

创建 Todo Items

server/controllers/todoitems.js

const TodoItem = require('../models').TodoItem

module.exports = {
 create(req, res) {
 return TodoItem
 .create({
 content: req.body.content,
 todoId: req.params.todoId,
 })
 .then(todoItem => res.status(201).send(todoItem))
 .catch(error => res.status(400).send(error))
 },
}

server/controllers/index.js

const todos = require('./todos')
const todoItems = require('./todoitems')

module.exports = {
 todos,
 todoItems,
}

server/routes/index.js

const todosController = require('../controllers').todos
const todoItemsController = require('../controllers').todoItems

module.exports = (app) => {
 ...
 app.get('/api/todos', todosController.list)
 app.post('/api/todos/:todoId/items', todoItemsController.create)
}

postman 测试
查询某个 todo 中的所有 todo-items server/controllers/todos.js

const Todo = require('../models').Todo
const TodoItem = require('../models').TodoItem

module.exports = {
 create(req, res) {
 ...
 },

 list(req, res) {
 return Todo
 .findAll({
 include: [{
 model: TodoItem,
 as: 'todoItems'
 }]
 })
 .then(todos => res.status(200).send(todos))
 .catch(error => res.status(400).send(error))
 },
}

获取指定 todo

server/controllers/todos.js

const Todo = require('../models').Todo
const TodoItem = require('../models').TodoItem

module.exports = {
 create(req, res) {
 ...
 },

 list(req, res) {
 ...
 },

 retrieve(req, res) {
 return Todo
 .findById(req.params.todoId, {
 include: [{
 model: TodoItem,
 as: 'todoItems'
 }]
 })
 .then(todo => {
 if (!todo) {
 return res.status(400).send({
 message: 'Todo Not Found'
 })
 }
 return res.status(200).send(todo)
 })
 .catch(error => res.status(400).send(error))
 },
}

修改路由 server/routes/index.js

const todosController = require('../controllers').todos
const todoItemsController = require('../controllers').todoItems

module.exports = (app) => {
 ...
 app.get('/api/todos/:todoId', todosController.retrieve)
 ...

更新一个 todo

server/controllers/todos.js

update(req, res) {
 return Todo
 .findById(req.params.todoId, {
 include: [{
 model: TodoItem,
 as: 'todoItems'
 }]
 })
 .then(todo => {
 if (!todo) {
 return res.status(400).send({
 message: 'Todo Not Found'
 })
 }
 return todo
 .update({
 title: req.body.title || todo.title,
 })
 .then(() => res.status(200).send(todo))
 .catch((error) => res.status(400).send(error))
 })
},

server/routes/index.js

...
app.put('/api/todos/:todoId', todosController.update)
...

删除 todo

server/controllers/todos.js

destroy(req, res) {
 return Todo
 .findById(req.params.todoId)
 .then(todo => {
 if (!todo) {
 return res.status(400).send({
 message: 'Todo Not Found'
 })
 }

 return todo
 .destroy()
 .then(() => res.status(204).send())
 .catch(error => res.status(400).send(error))
 })
 .catch(error => res.status(400).send(error))
}

server/routes/index.js

...
app.delete('/api/todos/:todoId', todosController.destroy)
...

更新和删除 todo items

server/controllers/todoitems.js

const TodoItem = require('../models').TodoItem

module.exports = {
 create(req, res) {
 return TodoItem
 .create({
 content: req.body.content,
 todoId: req.params.todoId,
 })
 .then(todoItem => res.status(201).send(todoItem))
 .catch(error => res.status(400).send(error))
 },

 update(req, res) {
 return TodoItem
 .find({
 where: {
 id: req.params.todoItemId,
 },
 })
 .then(todoItem => {
 if (!todoItem) {
 return res.status(400).send({message: 'TodoItem Not Found'})
 }

 return todoItem
 .update({
 content: req.body.content || todoItem.content,
 complete: req.body.complete || todoItem.complete
 })
 .then(updatedTodoItem => res.status(200).send(updatedTodoItem))
 .catch(error => res.status(400).send(error))
 })
 .catch(error => res.status(400).send(error));
 },

 destroy(req, res) {
 return TodoItem
 .find({
 where: {
 id: req.params.todoItemId,
 },
 })
 .then(todoItem => {
 if (!todoItem) {
 return res.status(400).send({message: 'TodoItem Not Found'})
 }
 return todoItem
 .destroy()
 .then(() => res.status(204).send())
 .catch(error => res.status(400).send(error))
 })
 .catch(error => res.status(400).send(error))
 }
}

server/routes/index.js

const todosController = require('../controllers').todos
const todoItemsController = require('../controllers').todoItems

module.exports = (app) => {
 app.get('/api', (req, res) => res.status(200).send({
 message: 'Welcome to the Todos API'
 }))
 app.post('/api/todos', todosController.create)
 app.get('/api/todos', todosController.list)
 app.get('/api/todos/:todoId', todosController.retrieve)
 app.put('/api/todos/:todoId', todosController.update)
 app.delete('/api/todos/:todoId', todosController.destroy)

 app.post('/api/todos/:todoId/items', todoItemsController.create)
 app.put('/api/todos/:todoId/items/:todoItemId', todoItemsController.update)
 app.delete('/api/todos/:todoId/items/:todoItemId', todoItemsController.destroy)

 app.all('/api/todos/:todoId/items', (req, res) => {
 res.status(405).send({
 message: 'Method Not Allowed'
 })
 })
}

Harp.js

ldxyzjl@163.com (张景林) — Fri, 07 Apr 2017 08:29:05 +0000

Harp.js?

Harp.js

The static web server with built-in preprocessing. Harp serves Jade, Markdown, EJS, CoffeeScript, Sass, LESS and Stylus as HTML, CSS & JavaScript—no configuration necessary.

How to use

install

npm i -g harp

create website

harp init hello-harp
cd hello-harp
harp server

compile

harp compile

metadata

_data.json

"team": {
 "title": "Team page",
 "members": ["Rob", "Brock", "Jorge"]
}

ejs or jade

h1= title
ul
 each member in members
 li= member

JavaScript 函数式编程（二）

ldxyzjl@163.com (张景林) — Mon, 27 Mar 2017 05:39:51 +0000

高阶函数（Higher-Order Functions）

const forEach = (array, fn) => {
 let i
 for (i = 0; i < array.length; i++) {
 fn(array[i])
 }
}

let array = [1, 2, 3]
forEach(array, (data) => console.log(data))

现在我们已经看到了如何创建和执行高阶函数。一般来说，高阶函数通常用来抽象常见的问题。换句话说，高阶函数只不过是定义抽象。

forEach本质上是遍历数组。如何遍历JavaScript对象？遍历JavaScript对象具有以下步骤：

迭代给定对象的所有键。
确定键属于自己的对象。
如果步骤2为真，则获取键的值。

const forEachObject = (obj, fn) => {
 for (let prop in obj) {
 if (obj.hasOwnProperty(prop)) {
 fn(prop, obj[prop])
 }
 }
}

let object = {a: 1, b: 2}
forEachObject(object, (k, v) => console.log(k + ":" + v))

让我们创建一个名为unless的函数，这是一个简单的函数，它需要一个断言（应该是true或false）; 如果断言是假，则调用fn。

const forEach = (array, fn) => {
 let i
 for (i = 0; i < array.length; i++) {
 fn(array[i])
 }
}

const unless = (predicate, fn) => {
 if (!predicate)
 fn()
}

forEach([1,2,3,4,5,6,7], (number) => {
 unless((number % 2), () => {
 console.log(number, ' is even')
 })
})

在上述情况下，我们从数组列表中获取偶数。如果我们要从0到100获得偶数的列表怎么办？我们不能在这里使用（当然我们可以，如果我们有数组有[0,1,2 …..，100]）。我们来看看另一个叫做times的高阶函数。

const unless = (predicate, fn) => {
 if (!predicate)
 fn()
}

const times = (times, fn) => {
 for (let i = 0; i < times; i++)
 fn(i)
}

times(20, (n) => {
 unless(n % 2, () => console.log(n, 'is even'))
})

现实世界中的高阶函数

every Function

通常作为JavaScript开发人员，我们需要检查内容数组是否是数字，自定义对象或其他内容。我们通常写典型的循环方法来解决这些问题。但是让我们把它们抽成一个叫做every函数。每个函数都有两个参数：数组和函数。它检查数组的所有元素是否被传递函数求值为true。ES6规格中， for..of循环可用于迭代数组元素

const every = (arr, fn) => {
 let result = true;
 for (const value of arr) {
 result = result && fn(value)
 }

 return result
}

every([NaN, NaN, NaN], isNaN) // true
every([NaN, NaN, 4], isNaN) // false

every 一个典型的高阶函数，易于实现，同时它也非常有用！

some Function

类似于every函数，我们也有一个称为some的函数。 some函数与every函数完全相反，如果数组中的任何一个元素对传递的函数返回true，那么some函数将返回true。 some函数也被称为any函数。为了实现some函数，我们使用|| 而不是 &&

const some = (arr, fn) => {
 let result = false;
 for (const value of arr) {
 result = result || fn(value)
 }

 return(result)
}

console.log(some([NaN, NaN, 4], isNaN)) // true
console.log(some([2, 3, 4], isNaN)) // false

sort Function

sort是JavaScript的Array原型中提供的内置函数。

var fruit = ['cherries', 'apples', 'bananas'];
console.log(fruit.sort())
// ["apples", "bananas", "cherries"]

排序函数是一个高阶函数，它接受一个函数作为其参数，这将有助于排序函数来决定排序逻辑。

arr.sort([compareFunction])

这里的compareFunction是可选的。如果没有提供compareFunction，则通过将元素转换为字符串并以Unicode代码顺序对比字符串进行排序。为了在执行排序时将元素与我们自己的逻辑进行比较，我们需要设计我们自己compareFunction。我们可以感觉到排序函数的设计如此灵活，以便它可以对JavaScript世界中的任何数据进行排序，只要我们通过一个compareFunction。排序功能是灵活的，由于高阶功能的本质！

const people = [
 {firstname: "aaFirstName", lastname: "cclastName"},
 {firstname: "ccFirstName", lastname: "aalastName"},
 {firstname:"bbFirstName", lastname:"bblastName"}
]

// compare firstname
people.sort((a, b) => {
 return (a.firstname < b.firstname) ? -1 : (a.firstname > b.firstname) ? 1 : 0
})

// compare lastname
people.sort((a,b) => {
 return (a.lastname < b.lastname) ? -1 : (a.lastname > b.lastname) ? 1 : 0
})

我们的compareFunction的算法，可以做得更好吗？我们可以将上述逻辑抽象成一个函数吗,而不是每次写比较函数？正如你在上面的例子中看到的，我们写了两个函数，用于比较firstName和lastName几乎相同的重复代码。我们用高阶函数来解决这个问题。现在我们要设计的函数将不会以函数为参数，而是返回一个函数。（记住HOC也可以返回一个函数）。

const people = [
 {firstname: "aaFirstName", lastname: "cclastName"},
 {firstname: "ccFirstName", lastname: "aalastName"},
 {firstname:"bbFirstName", lastname:"bblastName"}
]

const sortBy = (property) => {
 return (a, b) => {
 return (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0
 }
}

people.sort(sortBy('lastname'))

JavaScript 函数编程（一）

ldxyzjl@163.com (张景林) — Mon, 27 Mar 2017 05:15:08 +0000

函数式编程的简单术语

什么是函数式编程？为什么很重要？

数学中的函数

f(x)= Y

函数F，它以X为参数，并返回输出Y。在定义中有重要的含义：

函数必须有参数。
函数必须始终返回一个值。
函数只能对其接收参数（即X）起作用，而不是外部。
对于给定的X，将只有一个Y。

函数式编程技术主要基于数学函数及其思想，我们将会看到数学函数的想法以及如何使用它们来理解函数式编程。

想象一下，我们必须编写一个执行税收计算的函数。

var percentValue = 5;
var calculateTax = (value) => { return value/100 * (100 + percentValue) }
console.log(calculateTax(100))

以上的功能calculateTax完全符合我们要做的。看起来整洁，不是吗？我们暂停一下，就我们的数学定义分析上述功能。我们的数学函数术语的关键之一是函数逻辑不应该依赖于外部世界。在我们上面定义的函数calculateTax中，我们使函数取决于全局变量percentValue。因此，我们创建的上述函数在数学意义上不能被称为真正的函数。所以我们来解决一下。

修复很简单：我们只需要将percentValue作为我们的函数参数：

var calculateTax = (value, percentValue) => { return value/100 * (100 + percentValue) }

现在我们的函数calculateTax可以被称为真正的函数。我们刚刚在calculateTax函数中消除了全局变量访问。删除函数内的全局变量访问使得测试变得容易。函数式编程是一个范例，我们将在其中创建功能，通过依赖于其输入来实现其逻辑。这样可以确保在多次调用时函数将返回相同的结果。该功能也不会改变外部任何数据，导致可高速缓存和可测试的代码库。

引用透明（Referential Transparency）

所有的函数都将为相同的输入返回相同的值，而把这个特征称为引用透明。

var identity = (i) => { return i }
sum(4,5) + identity(1)
//使用我们的引用透明定义，我们可以将上述语句转换为：
sum(4,5) + 1

现在这个过程称为替代模型(Substitution model)，因为您可以直接用返回值替换函数的结果（主要是因为函数的逻辑不依赖于其他全局变量）。

这可以产生并行代码和缓存。

想象一下，使用这个模型，您可以轻松地使用多个线程运行上述函数，甚至不需要同步！为什么？同步的原因来自线程在并行运行时不应该对全局数据采取行动的事实。

而且由于函数将为给定的输入返回相同的值，所以实际上可以缓存它！例如，假设有一个叫做“factorial”的函数，它计算给定数字的阶乘。我们都知道’5’的阶乘将是’120’。如果用户第二次调用“5”的“factorial”怎么办？如果“因子”函数遵循参照透明度，那么我们知道结果将像以前一样是“120”（并且只取决于输入参数）。考虑到这个特征，我们可以缓存我们的“factorial”函数的值。因此，如果第二次调用“factorial”，输入为“5”，我们可以返回缓存的值而不是再次计算。

强制性，声明性，抽象性

假设你有一个列表或数组，并想要遍历数组并将其打印到控制台。代码可能如下所示：

var array = [1,2,3]
for(i=0;i<array.length;i++)
 console.log(array[i])

工作正常但是，在上述解决问题的方法中，我们正在准确地告诉我们如何做到这一点。例如，我们已经编写了一个隐含的for循环，并使用索引计算数组长度并打印项目。这里的任务是什么？ “打印数组元素”对吧？但是看起来我们正在告诉编译器该怎么做。在这种情况下，我们告诉“获取数组长度，循环我们的数组，使用索引获取数组的每个元素”。我们称之为“命令式”解决方案。

命令编程就是告诉编译器“怎么做”事情。

我们现在将切换到硬币的另一面，声明式编程。在声明式编程中，我们将要告诉编译器需要做什么，而不是“如何”的部分。 “如何”部分被抽象为共同的功能（这些功能被称为高阶函数，我们将在后面介绍）。现在我们可以使用内建的forEach函数来迭代数组并进行打印。

var array = [1,2,3]
array.forEach((element) => console.log(element))

上面的代码段打印完全相同的输出。但是在这里我们已经删除了“如何”的部分，如“获取数组长度，循环我们的数组，使用索引获取数组的每个元素”等。我们使用了一个抽象的函数，它实现了“如何”部分。

函数式编程是以抽象的方式创建函数，可以由代码的其他部分重用。

纯函数（Pure Functions）

纯函数是为给定输入返回相同输出的函数。

var double = (value) => value * 2;

上述函数“double”是一个纯函数，只是因为给定一个输入，它将始终返回相同的输出。使用输入5调用总是将结果返回为10！纯函数服从引用透明。因此，我们可以用10替换双（5），没有任何犹豫。

纯函数产生可测试代码
纯函数产生合理的代码

并行代码

纯函数允许我们并行运行代码。由于纯函数不会改变其任何环境，所以这意味着我们不需要担心所有的同步！

缓存

由于纯函数总是为给定的输入返回相同的输出，我们可以缓存功能输出。想象一下，我们有一个功能耗时的计算，我们将这个函数命名为longRunningFunction

var longRunningFunction = (ip) => { //do long running tasks and return }

如果longRunningFunction函数是一个纯函数，那么我们知道对于给定的输入，它将返回给我们相同的输出！想象一下，我们有一个对象，它保留longRunningFunction的所有函数调用结果

var longRunningFnBookKeeper = { 2 : 3, 4 : 5 }
//check if the key present in longRunningFnBookKeeper
//if get back the result else update the bookkeeping object
longRunningFnBookKeeper.hasOwnProperty(ip) ?
 longRunningFnBookKeeper[ip] :
 longRunningFnBookKeeper[ip] = longRunningFunction(ip)

管道和组合

使用纯函数，我们将在该函数中仅做一件事情。我们已经看到，纯函数将如何通过查看其名称来作为对该功能的自我理解。纯函数的设计应该只有一件事。只做一件事情就是一个UNIX哲学; 我们将在实现我们的纯函数时遵循相同的规定。在UNIX和LINUX平台中有许多命令，用于日常任务。例如，我们使用cat打印文件的内容，grep来搜索文件，wc来计算行数等。这些命令一次解决一个问题。但是我们可以组合或管理这些复杂的任务。

组合不仅仅是UNIX / LINUX命令行的唯一，而是函数式编程范例的核心。我们称之为函数组合。

(FMS03)Vim 的插件

ldxyzjl@163.com (张景林) — Sat, 03 Dec 2016 05:47:01 +0000

Vim 除了强大的键盘模式以外, Vim 还有插件功能, 可以通过插件将 Vim 的功能增强, 经过多年的发展, Vim 的插件系统有着庞大的规模, 有很多号称神级的插件, 是很多编辑器的模仿对象.

怎么管理插件

插件的安装一般通过插件管理器来进行安装. Vim 的插件管理器有很多种, 我采用的是pathogen 管理, 你也可以采用其他的管理方式, 比如常见的 vbundle, 请自行 google 之.

在pathogen 的主页上可以学习到安装方式.

mkdir -p ~/.vim/autoload ~/.vim/bundle && \
curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim

进入到新建的 bundle 目录, 下载相应的插件. 下面列出来我用的一些常用的插件

" 自动关闭括号, 也就是输入左括号(, 然后自动添加右括号), 支持{} [] ()
https://github.com/vim-scripts/AutoClose.git

" 迅速打开当前目录下的所有文件, 支持模糊查找, 按下 ctrl+p 组合件之后, 输入要查找的文件名的一部分, 快速定位, 回车打开, vim 神器之一
https://github.com/kien/ctrlp.vim.git

" html 神器之一, 其他编辑器也有相应的实现
https://github.com/mattn/emmet-vim.git

" 自动完成插件, 需要 lua 支持, 记得我们在安装 vim 的时候增加了 --with-lua 的选项了么? 在 Windows 平台的 vim 中不支持 lua, 需要自行编译 vim 增加 lua 支持, Windows 充满了大坑啊! MacOS 你不变的选择.
https://github.com/Shougo/neocomplete.vim.git

" 缩进美化, 对不同层级的缩进增加可视化竖条
https://github.com/nathanaelkane/vim-indent-guides.git

" vim 神器之一, 快速定位到你需要的位置
https://github.com/easymotion/vim-easymotion.git

" 美化 vim 的状态条
https://github.com/Lokaltog/vim-powerline.git

" solarized 配色, 最流行的一种配色
https://github.com/altercation/vim-colors-solarized.git

" vim 的侧边文件管理器, 不过我用了 ctrl+p 之后, 很少用到它
https://github.com/scrooloose/nerdtree.git

怎么安装

我举一个例子, 比如 vim-colors-solarized 来说明.

cd ~/.vim/bundle
git clone --depth 1 https://github.com/altercation/vim-colors-solarized.git

ok, 大功告成. 不过一般的情况下我们还需要在 .vimrc 中进行配置, 很多插件有很多的配置, 请自行在每个插件的网址中详细查看.

附上我的完整 .vimrc 配置.


let mapleader=";"

nmap <Leader>h 0
nmap <Leader>l $
vnoremap <Leader>y "+y
nmap <Leader>p "+p
nmap <Leader>q :q<CR>

" 在 vim 中, :vs 垂直分隔一个窗口, :sp(lit) 水平分割一个窗口, 然后使用下面四个映射命令, 在多个窗口中移动.
nmap <Leader>wh <C-W>h
nmap <Leader>wl <C-W>l
nmap <Leader>wj <C-W>j
nmap <Leader>wk <C-W>k

function! CBProcess()
 if (getline(".")[col(".")-2] == '{' && getline(".")[col(".")-1] == '}') || (getline(".")[col(".")-2] == '[' && getline(".")[col(".")-1] == ']') || (getline(".")[col(".")-2] == '(' && getline(".")[col(".")-1] == ')')
 return "\<CR>\<C-o>O"
 else
 return "\<CR>"
 endif
endfunction

inoremap <expr><CR> CBProcess()
inoremap ;; <C-o>$;<CR>

" 映射启动 NERDTreeToggle 插件的快捷键
map <Leader>n :NERDTreeToggle<CR>

" 为了让插件生效, 必须配置插件管理器
execute pathogen#infect()

filetype plugin indent on

syntax on
syntax enable


set autowrite
set autowriteall
set ignorecase
set hlsearch
set incsearch
set smartcase
set gdefault
set showmatch

set autoindent
set ts=4 sts=4 sw=4 expandtab

set backspace=indent,eol,start
set noswapfile
set visualbell
set cursorline
set number
set laststatus=2
set ruler

set encoding=utf-8
set fileencoding=utf-8

" 设置背景颜色, 采用亮色的 solarized, 也可以设置为 dark 采用暗色调
set background=light
colorscheme solarized
set guifont=Menlo:h20

" 设置 indent guides 插件的参数
let g:indent_guides_enable_on_vim_startup=1
let g:indent_guides_start_level=1
let g:indent_guides_guide_size=1

" 设置 neocomplete
let g:neocomplete#enable_at_startup=1
let g:neocomplete#enable_smart_case=1

" 设置 emmet 的展开方式快捷键
inoremap <expr><TAB> pumvisible() ? "\<C-n>" : "\<TAB>"
autocmd FileType css setlocal omnifunc=csscomplete#CompleteCSS
autocmd FileType html,markdown setlocal omnifunc=htmlcomplete#CompleteTags
autocmd FileType javascript setlocal omnifunc=javascriptcomplete#CompleteJS
autocmd FileType python setlocal omnifunc=pythoncomplete#Complete
autocmd FileType xml setlocal omnifunc=xmlcomplete#CompleteTags

" 设置 easymotion 是否区分大小写
let g:EasyMotion_smartcase=1

有问题, 请联系我.