1
{
2
  "name": "my-project",
3
  "version": "1.0.0",
4
  "description": "项目描述",
5
  "main": "index.js",
6
  "scripts": {
7
    "start": "node index.js",
8
    "dev": "nodemon index.js",
9
    "build": "webpack --mode production",
10
    "test": "jest",
11
    "lint": "eslint ."
12
  },
13
  "keywords": ["nodejs", "javascript"],
14
  "author": "Your Name <email@example.com>",
15
  "license": "MIT",
16
  "repository": {
17
    "type": "git",
18
    "url": "https://github.com/username/project.git"
19
  },
20
  "bugs": {
21
    "url": "https://github.com/username/project/issues"
22
  },
23
  "homepage": "https://github.com/username/project#readme",
24
  "dependencies": {},
25
  "devDependencies": {}
26
}

1
// 导出方式 1: export
2
export const add = (a, b) => a + b;
3
export const subtract = (a, b) => a - b;
4

5
// 导出方式 2: export default
6
const add = (a, b) => a + b;
7
export default add;
8

9
// 导出方式 3: export { }
10
const add = (a, b) => a + b;
11
export { add };
12

13
// 导入
14
import add from './math.js';
15
import { add, subtract } from './math.js';
16
import * as math from './math.js';

1
const path = require('path');
2

3
// 路径拼接
4
path.join('/foo', 'bar', 'baz/asdf');
5
// → '/foo/bar/baz/asdf'
6

7
// 解析为绝对路径
8
path.resolve('index.js');
9
// → '/Users/me/project/index.js'
10

11
path.resolve('/foo', './bar');
12
// → '/foo/bar'
13

14
// 获取路径信息
15
path.basename('/foo/bar/index.js');  // → 'index.js'
16
path.dirname('/foo/bar/index.js');   // → '/foo/bar'
17
path.extname('/foo/bar/index.js');   // → '.js'
18

19
// 判断路径类型
20
path.isAbsolute('/foo/bar');   // → true
21
path.isAbsolute('./foo/bar');  // → false
22

23
// 解析路径
24
path.parse('/foo/bar/index.js');
25
// → { root: '/', dir: '/foo/bar', base: 'index.js', ext: '.js', name: 'index' }
26

27
// 路径格式化
28
path.format({
29
  dir: '/foo/bar',
30
  name: 'index',
31
  ext: '.js'
32
});
33
// → '/foo/bar/index.js'
34

35
// 跨平台路径分隔符
36
path.sep;           // Linux/macOS: '/', Windows: '\\'
37
path.delimiter;     // Linux/macOS: ':', Windows: ';'

1
const fs = require('fs');
2
const fsPromises = require('fs').promises;  // Promise 风格
3

4
// 同步读取
5
const content = fs.readFileSync('./file.txt', 'utf8');
6

7
// 异步回调风格
8
fs.readFile('./file.txt', 'utf8', (err, data) => {
9
  if (err) throw err;
10
  console.log(data);
11
});
12

13
// Promise 风格 (Node.js 10+)
14
(async () => {
15
  const data = await fsPromises.readFile('./file.txt', 'utf8');
16
  console.log(data);
17
})();
18

19
// 同步方法列表
20
fs.readFileSync()
21
fs.writeFileSync()
22
fs.appendFileSync()
23
fs.mkdirSync()
24
fs.rmdirSync()
25
fs.readdirSync()
26
fs.statSync()
27
fs.existsSync()
28
fs.copyFileSync()
29
fs.unlinkSync()
30
fs.renameSync()
31

32
// 异步方法列表
33
fs.readFile()
34
fs.writeFile()
35
fs.appendFile()
36
fs.mkdir()
37
fs.rmdir()
38
fs.readdir()
39
fs.stat()
40
fs.access()
41
fs.copyFile()
42
fs.unlink()
43
fs.rename()
44

45
// Promise 方法 (fs.promises)
46
fsPromises.readFile()
47
fsPromises.writeFile()
48
fsPromises.mkdir()
49
fsPromises.readdir()
50
fsPromises.stat()
51
fsPromises.access()

1
const os = require('os');
2

3
os.platform();      // 'linux', 'darwin', 'win32'
4
os.arch();           // 'x64', 'arm64'
5
os.release();        // 操作系统版本
6
os.type();           // 'Linux', 'Darwin', 'Windows_NT'
7
os.homedir();        // 用户主目录
8
os.tmpdir();         // 临时文件目录
9
os.hostname();       // 主机名
10
os.EOL;              // 换行符 '\n' (Linux/macOS) 或 '\r\n' (Windows)
11
os.cpus();           // CPU 信息
12
os.totalmem();       // 总内存 (bytes)
13
os.freemem();        // 空闲内存 (bytes)
14
os.networkInterfaces();  // 网络接口
15
os.uptime();         // 系统运行时间 (秒)
16
os.loadavg();        // 平均负载 (Linux/macOS)

1
const util = require('util');
2
const { promisify } = util;
3
const { callbackify } = util;
4

5
// 将回调函数转为 Promise
6
const fsReadFile = promisify(fs.readFile);
7
const data = await fsReadFile('./file.txt', 'utf8');
8

9
// 将 async 函数转为回调风格
10
const asyncFn = async () => {};
11
const callbackFn = callbackify(asyncFn);
12

13
// 格式化字符串
14
util.format('%s:%d', 'hello', 123);  // 'hello:123'
15
util.format('%s:%s', 'hello');       // 'hello:%s'
16

17
// inspect 对象查看
18
util.inspect({ a: 1, b: { c: 2 } });
19
// → "{ a: 1, b: { c: 2 } }"
20

21
// 类型检查
22
util.types.isPromise(p);           // 是否为 Promise
23
util.types.isArray(arr);           // 是否为数组
24
util.types.isDate(date);           // 是否为日期
25
util.types.isRegExp(regex);        // 是否为正则
26
util.types.isMap(map);             // 是否为 Map
27
util.types.isSet(set);             // 是否为 Set
28
util.types.isAsyncFunction(fn);    // 是否为 async 函数
29
util.types.isGeneratorFunction(fn);// 是否为生成器函数

1
const EventEmitter = require('events');
2

3
class MyEmitter extends EventEmitter {}
4

5
const emitter = new MyEmitter();
6

7
// 监听事件
8
emitter.on('event', (arg1, arg2) => {
9
  console.log('事件触发', arg1, arg2);
10
});
11

12
// 只触发一次的监听器
13
emitter.once('event', () => {
14
  console.log('只触发一次');
15
});
16

17
// 发送事件
18
emitter.emit('event', '参数1', '参数2');
19

20
// 移除监听器
21
emitter.off('event', listenerFn);
22
emitter.removeListener('event', listenerFn);
23

24
// 移除所有监听器
25
emitter.removeAllListeners();
26
emitter.removeAllListeners('event');
27

28
// 查看监听器数量
29
emitter.listenerCount('event');
30

31
// 查看所有监听器
32
emitter.listeners('event');
33

34
// 错误事件
35
emitter.on('error', (err) => {
36
  console.error('错误:', err);
37
});

1
const crypto = require('crypto');
2

3
// 创建哈希
4
const hash = crypto.createHash('sha256');
5
hash.update('hello');
6
console.log(hash.digest('hex'));
7

8
// 创建 HMAC
9
const hmac = crypto.createHmac('sha256', 'secret-key');
10
hmac.update('hello');
11
console.log(hmac.digest('hex'));
12

13
// 加密
14
const cipher = crypto.createCipher('aes192', 'password');
15
let encrypted = cipher.update('hello', 'utf8', 'hex');
16
encrypted += cipher.final('hex');
17

18
// 解密
19
const decipher = crypto.createDecipher('aes192', 'password');
20
let decrypted = decipher.update(encrypted, 'hex', 'utf8');
21
decrypted += decipher.final('utf8');
22

23
// 随机数据
24
crypto.randomBytes(16);            // 16 字节随机数据
25
crypto.randomUUID();               // UUID v4
26

27
// 生成密钥
28
crypto.generateKey('aes', { length: 256 });
29

30
// diffie-hellman 密钥交换
31
const dh = crypto.createDiffieHellman(2048);

1
const buffer = Buffer.alloc(10);       // 创建 10 字节缓冲区
2
const buffer = Buffer.from('hello');   // 从字符串创建
3
const buffer = Buffer.from([1, 2, 3]);  // 从数组创建
4

5
// 编码转换
6
buffer.toString('utf8');
7
buffer.toString('hex');
8
buffer.toString('base64');
9

10
// 写入
11
buffer.write('hello', 0, 5, 'utf8');
12

13
// 拼接
14
Buffer.concat([buf1, buf2, buf3]);
15

16
// 复制
17
buf.copy(targetBuf, targetStart, sourceStart, sourceEnd);
18

19
// 比较
20
buffer.compare(otherBuffer);
21

22
// 切片
23
buffer.slice(0, 5);
24

25
// 长度
26
buffer.length;

1
const { Readable, Writable, Transform, Duplex, pipeline } = require('stream');
2
const fs = require('fs');
3

4
// 读取流
5
const readStream = fs.createReadStream('./file.txt');
6
readStream.on('data', chunk => { /* 处理数据块 */ });
7
readStream.on('end', () => { /* 读取完成 */ });
8
readStream.on('error', err => { /* 错误处理 */ });
9

10
// 写入流
11
const writeStream = fs.createWriteStream('./output.txt');
12
writeStream.write('hello');
13
writeStream.end();
14
writeStream.on('finish', () => { /* 写入完成 */ });
15

16
// 管道 (pipe)
17
readStream.pipe(writeStream);
18

19
// pipeline (更好的错误处理)
20
pipeline(
21
  fs.createReadStream('./file.txt'),
22
  gzip(),
23
  fs.createWriteStream('./file.txt.gz'),
24
  (err) => { if (err) console.error('失败:', err); }
25
);
26

27
// Transform 流
28
const upperCase = new Transform({
29
  transform(chunk, encoding, callback) {
30
    this.push(chunk.toString().toUpperCase());
31
    callback();
32
  }
33
});

1
const http = require('http');
2
const https = require('https');
3
const fs = require('fs');
4

5
// 创建 HTTP 服务器
6
const server = http.createServer((req, res) => {
7
  res.statusCode = 200;
8
  res.setHeader('Content-Type', 'text/plain');
9
  res.end('Hello World');
10
});
11

12
server.listen(3000, '127.0.0.1', () => {
13
  console.log('服务器运行在 http://127.0.0.1:3000');
14
});
15

16
// HTTP 请求
17
http.get('http://api.example.com/data', (res) => {
18
  let data = '';
19
  res.on('data', chunk => { data += chunk; });
20
  res.on('end', () => { console.log(data); });
21
});
22

23
// HTTPS 请求
24
const options = {
25
  hostname: 'api.example.com',
26
  port: 443,
27
  path: '/data',
28
  method: 'GET'
29
};
30
https.request(options, (res) => {
31
  // 处理响应
32
});

1
const url = require('url');
2

3
// 解析 URL
4
const myURL = new URL('https://user:pass@host.com:8080/path?query=value#hash');
5

6
console.log(myURL.href);          // 完整 URL
7
console.log(myURL.protocol);      // 'https:'
8
console.log(myURL.host);           // 'host.com:8080'
9
console.log(myURL.hostname);       // 'host.com'
10
console.log(myURL.port);          // '8080'
11
console.log(myURL.pathname);       // '/path'
12
console.log(myURL.search);         // '?query=value'
13
console.log(myURL.searchParams);  // URLSearchParams
14
console.log(myURL.hash);          // '#hash'
15
console.log(myURL.username);      // 'user'
16
console.log(myURL.password);      // 'pass'
17

18
// URLSearchParams
19
const params = new URLSearchParams(myURL.search);
20
params.get('query');              // 'value'
21
params.set('query', 'newvalue');
22
params.append('page', '1');
23
params.has('query');              // true
24
params.delete('query');
25

26
// 旧式 url.parse (已废弃)
27
url.parse('https://example.com/path?query=value', true);

1
const querystring = require('querystring');
2

3
// 解析查询字符串
4
querystring.parse('name=test&age=18');
5
// → { name: 'test', age: '18' }
6

7
// 构建查询字符串
8
querystring.stringify({ name: 'test', age: 18 });
9
// → 'name=test&age=18'
10

11
// 编码
12
querystring.escape('name=test&age=18');
13
// → 'name%3Dtest%26age%3D18'
14

15
// 解码
16
querystring.unescape('name%3Dtest');
17
// → 'name=test'

1
const zlib = require('zlib');
2

3
// gzip 压缩
4
const gzip = zlib.createGzip();
5
const inp = fs.createReadStream('./file.txt');
6
const out = fs.createWriteStream('./file.txt.gz');
7
inp.pipe(gzip).pipe(out);
8

9
// 压缩数据
10
zlib.gzipSync(Buffer.from('hello'));
11

12
// 解压数据
13
zlib.unzipSync(Buffer.from(gzipData));
14

15
// 其他压缩格式
16
zlib.deflateSync();   // deflate
17
zlib.deflateRawSync(); // raw deflate
18
zlib.brotli*();       // brotli 压缩

1
const net = require('net');
2

3
// 创建 TCP 服务器
4
const server = net.createServer((socket) => {
5
  console.log('客户端连接:', socket.remoteAddress);
6

7
  socket.on('data', (data) => {
8
    console.log('收到数据:', data.toString());
9
    socket.write('服务器收到');
10
  });
11

12
  socket.on('end', () => {
13
    console.log('客户端断开');
14
  });
15

16
  socket.write('欢迎连接');
17
});
18

19
server.listen(8080, () => {
20
  console.log('TCP 服务器监听 8080 端口');
21
});
22

23
// 创建 TCP 客户端
24
const client = net.createConnection(8080, '127.0.0.1', () => {
25
  console.log('已连接到服务器');
26
  client.write('Hello Server');
27
});

1
const dns = require('dns');
2
const dnsPromises = require('dns').promises;
3

4
// 解析域名
5
dns.resolve4('example.com', (err, addresses) => {
6
  if (err) throw err;
7
  console.log('IPv4 地址:', addresses);
8
});
9

10
dns.resolve6('example.com');
11
dns.resolveMx('example.com');
12
dns.resolveTxt('example.com');
13
dns.resolveNs('example.com');
14
dns.resolveCname('example.com');
15
dns.resolveSoa('example.com');
16
dns.resolveSrv('example.com');
17
dns.reverse('93.184.216.34');
18

19
// Promise 风格
20
(async () => {
21
  const addresses = await dnsPromises.resolve4('example.com');
22
  console.log(addresses);
23
})();
24

25
// 反向解析
26
dns.reverse('93.184.216.34');
27

28
// 查找
29
dns.lookup('example.com', (err, address, family) => {
30
  console.log('地址:', address, '类型:', family); // family: 4 或 6
31
});