这是我参与「第四届青训营」笔记创作活动的第17天。

笔记小结： 通过本节课的学习了有关Node.js的基本知识，包含其应用场景、运行时结构以及如何编写 Http Server。在课程的最后部分，欧阳老师带我们拓展了Node.js贡献代码、编辑、诊断及追踪等。现对照课程内容顺序将笔记补充如下。

01. Node.js的应用场景

简单的说 Node.js 就是运行在服务端的 JavaScript。
Node.js 是一个基于 Chrome JavaScript 运行时建立的一个平台。
Node.js 是一个事件驱动 I/O 服务端 JavaScript 环境，基于 Google 的 V8 引擎，V8 引擎执行Javascript 的速度非常快，性能非常好。

前端工程化
- Bundle：webpack, vite, esbuild, parcel
- Uglify：uglifyjs
- Transpile：bablejs, typescript
- 其他语言加入竞争：esbuild（go）, parcel（rust）, prisma
- 现状：难以替代
Web服务端应用
- 学习曲线平缓，开发效率较高
- 运行效率接近常见的编译语言
- 社区生态丰富及工具链成熟(npm, V8 inspector)
- 与前端结合的场景会有优势(SSR)
- 现状：竞争激烈，Node.js有自己独特的优势
Electron跨端桌面应用
- 商业应用：vscode, slack, discord, zoom
- 大型公司内的效率工具
- 现状：大部分场景在选型时，都值得考虑
Node.js在字节
- BFF应用、SSR应用，举例：Modern.js
- 服务端应用，例如：头条搜索，西瓜视频，懂车帝
- Electron应用：飞连，飞书
- 每年新增1000+ Node.js应用

02. Node.js运行时结构

V8, libuv

V8：JavaScript Runtime，诊断调试工具(inspector)
libuv：eventloop(事件循环)， syscall (系统调用)
举例：用node-fetch发起请求时…

特点

异步I/O
当Node.js执行I/O操作时，会在响应返回后恢复操作，而不是阻塞线程并占用额外内存等待。

单线程

JS 单线程
- 实际：JS线程+uv线程池+V8任务线程池+V8 Inspector线程
优点：不用考虑多线程状态同步问题，也就不需要锁；同时还能比较高效地利用系统资源
缺点：阻塞会产生更多负面影响
- 解决办法：多进程或多线程

跨平台

跨平台 (大部分功能、api)
Node.js跨平台+JS无需编译环境(+ Web 跨平台+诊断工具跨平台)
- =开发成本低 (大部分场景无需担心跨平台问题) ，整体学习成本低

03. 编写 Http Server

安装Node.js

Mac,Linux推荐使用nvm。多版本管理。
Windows推荐 nvm4w 或是官方安装包。
安装慢，安装失败的情况，设置安装源

NVM_NODEJS_ORG_MRROR=https://npmmirror.com/mirrors/node nvm install 16

Http Server

首先编写一个server.js，如下

createServer 说明

req 请求，res响应

server.listen 说明

port 要监听的端口号，成功后的回调函数

const http = require('http');
const server = http.createServer((req, res) => {
    res.end('hello'); // 响应直接就是hello
});
const port = 3000;
server.listen(port, () => {
    console.log(`server listens on:${port}`);	// 监听3000端口
})

使用node启动，此时输入localhost:3000就可以看到hello

改为JSON版

const server = http.createServer((req, res) => {
    // receive body from client
    const bufs = [];    // 取传的数据
    req.on('data', data => {
        bufs.push(data);
    });
    req.on('end', () => {
        const buf = Buffer.concat(bufs).toString('utf-8');
        let msg = 'Hello';
        try {
            reqData = JSON.parse(buf);
            msg = reqData.msg;
        } catch (err) {
            res.end('invalid json');
        }
        // response
        const responseJson = {
            msg: `receive：${msg}`
        }
        res.setHeader('Content-Type', 'application/json');
        res.end(JSON.stringify(responseJson));
    });
});

Http Client

http.request(url[, options][, callback])

const http = require('http');
const body = JSON.stringify({ msg: 'hello from my own client' });
// [url] [option] [callback]
const req = http.request('http://127.0.0.1:3000', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'Content-Length': body.length,
    },
}, (res) => {   // 响应体   
    const bufs = [];
    res.on('data', data => {
        bufs.push(data);
    });
    res.on('end', () => {
        const buf = Buffer.concat(bufs);
        const receive = JSON.parse(buf);
        console.log('receive json.msg is:', receive);
    });
})
req.end(body);

Promisify

可以用 Promise + async和await 重写这两个例子 （why？）

当 await 关键字与异步函数一起使用时，它的真正优势就变得明显了 —— 事实上， await 只在异步函数里面才起作用。它可以放在任何异步的，基于 promise 的函数之前。它会暂停代码在该行上，直到 promise 完成，然后返回结果值。在暂停的同时，其他正在等待执行的代码就有机会执行了
async/await 让你的代码看起来是同步的，在某种程度上，也使得它的行为更加地同步。 await 关键字会阻塞其后的代码，直到promise完成，就像执行同步操作一样。它确实可以允许其他任务在此期间继续运行，但您自己的代码被阻塞。

function wait(t) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve();
        }, t);
    });
}
wait(1000).then(() => { console.log('get called'); });

const server = http.createServer(async (req, res) => {  // 注意这里的async
    // receive body from client 改成了Promise形式
    const msg = await new Promise((resolve, reject) => {    //执行完再交给msg
        const bufs = [];    
        req.on('data', data => {
            bufs.push(data);
        });
        req.on('error', (err) => {
            reject(err);
        })
        req.on('end', () => {
            const buf = Buffer.concat(bufs).toString('utf-8');
            let msg = 'Hello';
            try {
                reqData = JSON.parse(buf);
                msg = reqData.msg;
            } catch (err) {
                // 
            }
            resolve(msg);
        });
    });
    // response
    const responseJson = {
        msg: `receive：${msg}`
    }
    res.setHeader('Content-Type', 'application/json');
    res.end(JSON.stringify(responseJson));
});

静态文件

编写静态文件服务器

编写一个简单的静态服务，接受用户发过来的http请求，拿到图片的url约定为静态文件服务器磁盘上对应的路径，再把具体内容返回给用户。这次除了 http 模块，还需要 fs 模块和 path 模块

先编写一个简单的 index.html，放于static目录下

static_server.js

const http = require('http');
const fs = require('fs');
const path = require('path');
const url = require('url');
// __dirname是当前这个文件所在位置, ./为当前文件所在文件夹 folderPath即为static文件夹相对于当前文件路径
const folderPath = path.resolve(__dirname, './static');

const server = http.createServer((req, res) => {  // 注意这里的async
    // expected http://127.0.0.1:3000/index.html
    const info = url.parse(req.url);

    // static/index.html
    const filepath = path.resolve(folderPath, './'+info.path);
    console.log('filepath', filepath);
    // stream风格的api，其内部内存使用率更好
    const filestream = fs.createReadStream(filepath);
    filestream.pipe(res);
});
const port = 3000;
server.listen(port, () => {
    console.log(`server listens on:${port}`);
})

与高性能、可靠的服务相比，还差什么?
- CDN：缓存+加速
- 分布式储存，容灾

React SSR服务

SSR (server side rendering)有什么特点？
- 相比传统HTML模版引擎:避免重复编写代码
- 相比SPA (single page application)：首屏渲染更快，SEO（搜索引擎优化）友好
- 缺点：
  - 通常qps（每秒查询率）较低，前端代码编写时需要考虑服务端渲染情况
html 编写示例

const React = require('react');
const ReactDOMServer = require('react-dom/server');
const http = require('http');
function App(props) {
    return React.createElement('div', {}, props.children || 'Hello');
}
const server = http.createServer((req, res) => {
    res.end(`
        <!DOCTYPE html>
        <html>
            <head>
                <title>My Application</title>
            </head>
            <body>
                ${ReactDOMServer.renderToString(
                    React.createElement(App, {}, 'my_content'))}
                <script>
                    alert('yes');
                </script>
            </body>
        </html>
    `);
})
const port = 3000;
server.listen(port, () => {
    console.log('listening on: ', port);
})

SSR难点
- 需要处理打包代码
- 需要思考前端代码在服务端运行时的逻辑
- 移除对服务端无意义的副作用，或重置环境

Debug

V8 Inspector：开箱即用、特性丰富强大、与前端开发一致、跨平台
- node --inspect
- open http://localhost:9229/json
场景：
- 查看console.log内容
- breakpoint
- 高CPU、死循环：cpuprofile
- 高内存占用：heapsnapshot
- 性能分析

部署

部署要解决的问题：
- 守护进程：当进程退出时，重新拉起
- 多进程：cluster便捷地利用多进程
- 记录进程状态，用于诊断
容器环境：
- 通常有健康检查的手段，只需考虑多核 cpu 利用率即可

04. 延伸话题

快速了解Node.js代码

Node. js Core贡献入门

好处
- 从使用者的角色逐步理解底层细节，可以解决更复杂的问题，
- 自我证明，有助于职业发展;
- 解决社区问题，促进社区发展;
难点:
- 花时间

编译Node.js

为什么要学习编译Node.js
- 认知:黑盒到白盒，发生问题时能有迹可循
- 贡献代码的第一步
如何编译
- ./configure &&make install
- 演示：给net模块添加自定义属性

诊断/追踪

- 诊断是一个低频、重要同时也相当有挑战的方向。是企业衡量自己能否依赖一个门语言的重要参考。
- 技术咨询行业中的热门角色。
- 难点:
    - 需要了解Node.js底层，需要了解操作系统以及各种工具
    - 需要经验

WASM, NAPI

Node.js(因为V8)是执行WASM代码的天然容器，和浏览器WASM是同一运行时，同时Node.js支持WASI。
NAPI执行C接口的代码(C/C++/Rust…)，同时能保留原生代码的性能。
不同编程语言间通信的一种方案。

Node.js 与前端开发实战学习(1) | 青训营笔记