fs.open('/open/some/file.txt', 'r', (err, fd) => {
  if (err) throw err;
  fs.fstat(fd, (err, stat) => {
    if (err) throw err;
    // 各种操作

    // 必须关闭文件描述符！
    fs.close(fd, (err) => {
      if (err) throw err;
    });
  });
});

fs.access(path[, mode], callback) //测试 path 指定的文件或目录的用户权限。 mode 参数是一个可选的整数，指定要执行的可访问性检查。 文件访问常量定义了 mode 可选的值。 可以创建由两个或更多个值的位或组成的掩码（例如 fs.constants.W_OK | fs.constants.R_OK）  
fs.appendFile(path, data[, options], callback) //异步地追加数据到一个文件，如果文件不存在则创建文件。 data 可以是一个字符串或 Buffer  
fs.copyFile(src, dest[, flags], callback) //异步的将 src 拷贝到 dest
fs.createReadStream(path[, options])
fs.createWriteStream(path[, options])
//异步地创建目录。 完成回调只有一个可能的异常参数。 mode 默认为 0o777
fs.mkdir(path[, mode], callback)
fs.open(path, flags[, mode], callback) // 该回调有两个参数 (err, fd)
 // 从 fd 指定的文件中读取数据。buffer 是数据将被写入到的 buffer。offset 是 buffer 中开始写入的偏移量。length 是一个整数，指定要读取的字节数。position 指定从文件中开始读取的位置。 如果 position 为 null，则数据从当前文件读取位置开始读取，且文件读取位置会被更新。 如果 position 为一个整数，则文件读取位置保持不变。
fs.read(fd, buffer, offset, length, position, callback)
 // 读取一个目录的内容。 回调有两个参数 (err, files)，其中 files 是目录中不包括 '.' 和 '..' 的文件名的数组
fs.readdir(path[, options], callback)
fs.readFile(path[, options], callback)
fs.rename(oldPath, newPath, callback)
fs.rmdir(path, callback)
 // 异步地删除文件或符号链接。 除了可能的异常，完成回调没有其他参数，fs.unlink() 不能用于目录。 要删除目录，则使用 fs.rmdir(）
fs.unlink(path, callback)
fs.stat(path[, options], callback)
fs.write(fd, buffer[, offset[, length[, position]]], callback)
fs.writeFile(file, data[, options], callback)
fs.writeFileSync(file, data[, options])

Buffer 类
__dirname
__filename
clearImmediate(immediateObject)
clearInterval(intervalObject)
clearTimeout(timeoutObject)
console
exports
global
module
process
require()
setImmediate(callback[, ...args])
setInterval(callback, delay[, ...args])
setTimeout(callback, delay[, ...args])

const postData = querystring.stringify({
  'msg' : 'Hello World!'
});

const options = {
  hostname: 'www.google.com',
  port: 80,
  path: '/upload',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Content-Length': Buffer.byteLength(postData)
  }
};

const req = http.request(options, (res) => {
  console.log(`状态码: ${res.statusCode}`);
  console.log(`响应头: ${JSON.stringify(res.headers)}`);
  res.setEncoding('utf8');
  res.on('data', (chunk) => {
    console.log(`响应主体: ${chunk}`);
  });
  res.on('end', () => {
    console.log('响应中已无数据。');
  });
});

req.on('error', (e) => {
  console.error(`请求遇到问题: ${e.message}`);
});

// 写入数据到请求主体
req.write(postData);
req.end();

http.get('http://nodejs.org/dist/index.json', (res) => {
  const { statusCode } = res;
  const contentType = res.headers['content-type'];

  let error;
  if (statusCode !== 200) {
    error = new Error('请求失败。\n' +
                      `状态码: ${statusCode}`);
  } else if (!/^application\/json/.test(contentType)) {
    error = new Error('无效的 content-type.\n' +
                      `期望 application/json 但获取的是 ${contentType}`);
  }
  if (error) {
    console.error(error.message);
    // 消耗响应数据以释放内存
    res.resume();
    return;
  }

  res.setEncoding('utf8');
  let rawData = '';
  // 客户端读取数据，可读流 IncomingMessage
  res.on('data', (chunk) => { rawData += chunk; });
  res.on('end', () => {
    try {
      const parsedData = JSON.parse(rawData);
      console.log(parsedData);
    } catch (e) {
      console.error(e.message);
    }
  });
}).on('error', (e) => {
  console.error(`错误: ${e.message}`);
});

const http = require('http');
const keepAliveAgent = new http.Agent({ keepAlive: true });
options.agent = keepAliveAgent;
http.request(options, onResponseCallback);

onst http = require('http');
const net = require('net');
const url = require('url');

// 创建一个 HTTP 代理服务器
const proxy = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
proxy.on('connect', (req, cltSocket, head) => {
  // 连接到一个服务器
  const srvUrl = url.parse(`http://${req.url}`);
  const srvSocket = net.connect(srvUrl.port, srvUrl.hostname, () => {
    cltSocket.write('HTTP/1.1 200 Connection Established\r\n' +
                    'Proxy-agent: Node.js-Proxy\r\n' +
                    '\r\n');
    srvSocket.write(head);
    srvSocket.pipe(cltSocket);
    cltSocket.pipe(srvSocket);
  });
});

// 代理服务器正在运行
proxy.listen(1337, '127.0.0.1', () => {

  // 发送一个请求到代理服务器
  const options = {
    port: 1337,
    hostname: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80'
  };

  const req = http.request(options);
  req.end();

  req.on('connect', (res, socket, head) => {
    console.log('已连接！');

    // 通过代理服务器发送一个请求
    socket.write('GET / HTTP/1.1\r\n' +
                 'Host: www.google.com:80\r\n' +
                 'Connection: close\r\n' +
                 '\r\n');
    socket.on('data', (chunk) => {
      console.log(chunk.toString());
    });
    socket.on('end', () => {
      proxy.close();
    });
  });
});

const http = require('http');

const server = http.createServer((req, res) => {
  res.end();
});
server.on('clientError', (err, socket) => {
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
});
server.listen(8000);

// 返回 content-type = text/plain
const server = http.createServer((req, res) => {
    res.setHeader('Content-Type', 'text/html');
    res.setHeader('X-Foo', 'bar');
    res.writeHead(200, 'ok', { 'Content-Type': 'text/plain' });
    // 此方法向服务器发出信号，表明已发送所有响应头和主体，该服务器应该视为此消息已完成。 必须在每个响应上调用此 response.end() 方法
    res.end('ok');
});

// curl -k https://localhost:8000/
const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
};

https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('hello world\n');
}).listen(8000);

require(X) from module at path Y
1. If X is a core module,
   a. return the core module
   b. STOP
2. If X begins with '/'
   a. set Y to be the filesystem root
3. If X begins with './' or '/' or '../'
   a. LOAD_AS_FILE(Y + X)
   b. LOAD_AS_DIRECTORY(Y + X)
4. LOAD_NODE_MODULES(X, dirname(Y))
5. THROW "not found"

LOAD_AS_FILE(X)
1. If X is a file, load X as JavaScript text.  STOP
2. If X.js is a file, load X.js as JavaScript text.  STOP
3. If X.json is a file, parse X.json to a JavaScript Object.  STOP
4. If X.node is a file, load X.node as binary addon.  STOP

LOAD_INDEX(X)
1. If X/index.js is a file, load X/index.js as JavaScript text.  STOP
2. If X/index.json is a file, parse X/index.json to a JavaScript object. STOP
3. If X/index.node is a file, load X/index.node as binary addon.  STOP

LOAD_AS_DIRECTORY(X)
1. If X/package.json is a file,
   a. Parse X/package.json, and look for "main" field.
   b. let M = X + (json main field)
   c. LOAD_AS_FILE(M)
   d. LOAD_INDEX(M)
2. LOAD_INDEX(X)

LOAD_NODE_MODULES(X, START)
1. let DIRS=NODE_MODULES_PATHS(START)
2. for each DIR in DIRS:
   a. LOAD_AS_FILE(DIR/X)
   b. LOAD_AS_DIRECTORY(DIR/X)

NODE_MODULES_PATHS(START)
1. let PARTS = path split(START)
2. let I = count of PARTS - 1
3. let DIRS = []
4. while I >= 0,
   a. if PARTS[I] = "node_modules" CONTINUE
   b. DIR = path join(PARTS[0 .. I] + "node_modules")
   c. DIRS = DIRS + DIR
   d. let I = I - 1
5. return DIRS

(function(exports, require, module, __filename, __dirname) {
// 模块的代码实际上在这里
});

path.basename(path[, ext]) //返回一个 path 的最后一部分
    path.basename('/foo/bar/baz/asdf/quux.html'); // 返回: 'quux.html'  
    path.basename('/foo/bar/baz/asdf/quux.html', '.html');  // 返回: 'quux'

path.delimiter // 提供平台特定的路径分隔符：Windows 上是 ; POSIX 上是 : 
path.dirname(path) // 返回一个 path 的目录名
path.extname // 返回 path 的扩展名

path.format(pathObject) // 从一个对象返回一个路径字符串 
    /* pathObject <Object>
        dir <string>
        root <string>
        base <string>
        name <string>
        ext <string>
        如果提供了 pathObject.dir，则 pathObject.root 会被忽略
        如果提供了 pathObject.base 存在，则 pathObject.ext 和 pathObject.name 会被忽略
    */

path.parse(path) // 方法返回一个对象，对象的属性表示 path 的元素,与上面format正好相反
    /*
        path.parse('/home/user/dir/file.txt');
        // 返回:
        // { root: '/',
        //   dir: '/home/user/dir',
        //   base: 'file.txt',
        //   ext: '.txt',
        //   name: 'file' }
    */

path.join([...paths]) // 使用平台特定的分隔符把全部给定的 path 片段连接到一起，并规范化生成的路径,长度为零的 path 片段会被忽略。 如果连接后的路径字符串是一个长度为零的字符串，则返回 '.'，表示当前工作目录。
    /*
        path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
        // 返回: '/foo/bar/baz/asdf'

        path.join('foo', {}, 'bar');
        // 抛出 'TypeError: Path must be a string. Received {}'
    */

path.normalize(path) // 规范化给定的 path，并解析 '..' 和 '.' 片段
    /*
        path.normalize('/foo/bar//baz/asdf/quux/..');
        // 返回: '/foo/bar/baz/asdf'
    */

path.relative(from, to) //从 from 到 to 的相对路径（基于当前工作目录）。 如果 from 和 to 各自解析到同一路径（调用 path.resolve()），则返回一个长度为零的字符串。 如果 from 或 to 传入了一个长度为零的字符串，则当前工作目录会被用于代替长度为零的字符串。
    /*
        path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
        // 返回: '../../impl/bbb'
    */

path.resolve([...paths]) //把一个路径或路径片段的序列解析为一个 **绝对路径**。给定的路径的序列是从右往左被处理的，后面每个 path 被依次解析，直到构造完成一个绝对路径。 例如，给定的路径片段的序列为：/foo、/bar、baz，则调用 path.resolve('/foo', '/bar', 'baz') 会返回 /bar/baz。
//如果处理完全部给定的 path 片段后还未生成一个绝对路径，则当前工作目录会被用上。
//生成的路径是规范化后的，且末尾的斜杠会被删除，除非路径被解析为根目录。
//长度为零的 path 片段会被忽略。
//如果没有传入 path 片段，则 path.resolve() 会返回当前工作目录的绝对路径。
    /*
        path.resolve('/foo/bar', './baz');
        // 返回: '/foo/bar/baz'

        path.resolve('/foo/bar', '/tmp/file/');
        // 返回: '/tmp/file'

        path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif');
        // 如果当前工作目录为 /home/myself/node，
        // 则返回 '/home/myself/node/wwwroot/static_files/gif/image.gif'
    */

path.isAbsolute(path) // 判定 path 是否为一个绝对路径
path.sep //提供了平台特定的路径片段分隔符 Windows 上是 \  POSIX 上是 /

'exit' 事件 // 两种情况下 'exit' 事件会被触发：显式调用 process.exit() 方法，使得 Node.js 进程即将结束；Node.js 事件循环数组中不再有额外的工作，使得 Node.js 进程即将结束。'exit' 事件监听器的回调函数，只允许包含同步操作。
'message' 事件 // 如果 Node.js 进程是由 IPC 通道的方式创建的（详见子进程和集群文档），当子进程收到父进程发送的消息时(消息通过 childprocess.send() 发送），会触发 'message' 事件。
'rejectionHandled' 事件 // 如果有 Promise 被 rejected，并且此 Promise在 Node.js 事件循环的下次轮询及之后期间，被绑定了一个错误处理器（例如使用 promise.catch()），会触发 'rejectionHandled' 事件。

process.argv // process.argv 属性返回一个数组，这个数组包含了启动Node.js进程时的命令行参数。第一个元素为process.execPath。如果需要获取argv[0]的值请参见  process.argv0。第二个元素为当前执行的JavaScript文件路径。剩余的元素为其他命令行参数。
process.argv0 // 保存Node.js启动时传入的argv[0]参数值的一份只读副本
process.cwd() // 返回 Node.js 进程当前工作的目录
process.env // 返回一个包含用户环境信息的对象
process.execArgv // 返回当Node.js进程被启动时，Node.js特定的命令行选项。 这些选项在process.argv属性返回的数组中不会出现，并且这些选项中不会包括Node.js的可执行脚本名称或者任何在脚本名称后面出现的选项。 这些选项在创建子进程时是有用的，因为他们包含了与父进程一样的执行环境信息
process.execPath // 返回启动Node.js进程的可执行文件所在的绝对路径
process.nextTick(callback[, ...args]) // process.nextTick()方法将 callback 添加到"next tick 队列"。 一旦当前事件轮询队列的任务全部完成，在next tick队列中的所有callbacks会被依次调用。这种方式不是setTimeout(fn, 0)的别名。它更加有效率。事件轮询随后的ticks 调用，会在任何I/O事件（包括定时器）之前运行
process.platform // 返回字符串，标识Node.js进程运行其上的操作系统平台
process.send(message[, sendHandle[, options]][, callback]) // 如果Node.js进程是通过进程间通信产生的，那么，process.send()方法可以用来给父进程发送消息。 接收到的消息被视为父进程的ChildProcess对象上的一个'message'事件
process.version // 返回Node.js的版本信息
process.versions // 返回一个对象，此对象列出了Node.js和其依赖的版本信息

process.stdin // process.stdin 属性返回连接到 stdin (fd 0)的流。 它是一个net.Socket(它是一个Duplex流)，除非 fd 0指向一个文件，在这种情况下它是一个Readable流。

process.stdout // process.stdout 属性返回连接到 stdout (fd 1)的流。 它是一个net.Socket (它是一个Duplex流)， 除非 fd 1 指向一个文件，在这种情况下它是一个[可写][]流。

/*1:声明变量*/
var num1, num2;
/*2：向屏幕输出，提示信息，要求输入num1*/
process.stdout.write('请输入num1的值：');
/*3：监听用户的输入*/
process.stdin.on('data', function (chunk) {
    if (!num1) {
        num1 = Number(chunk);
        /*4：向屏幕输出，提示信息，要求输入num2*/
        process.stdout.write('请输入num2的值');
    } else {
        num2 = Number(chunk);
        process.stdout.write('结果是：' + (num1 + num2));
    }
});

// 例子，欧元符号（€）的三个 UTF-8 编码的字节被分成三次操作写入：
const { StringDecoder } = require('string_decoder');
const decoder = new StringDecoder('utf8');

decoder.write(Buffer.from([0xE2]));
decoder.write(Buffer.from([0x82]));
console.log(decoder.end(Buffer.from([0xAC])));

const { URL } = require('url');
const myURL = new URL('https://a:b@你好你好?abc#foo');

console.log(myURL.href);
  // 输出 https://a:b@xn--6qqa088eba/?abc#foo

console.log(myURL.toString());
  // 输出 https://a:b@xn--6qqa088eba/?abc#foo

console.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));
  // 输出 'https://你好你好/?abc'

console.log(myURL.search);
  // 输出 ?abc

myURL.search = 'abc=xyz';
console.log(myURL.href);
  // 输出 https://a:b@xn--6qqa088eba/?abc=xyz#foo

url.hash // 获取及设置URL的分段(hash)部分
url.host // 获取及设置URL的主机(host--hostname+port)部分 
url.hostname // 获取及设置URL的主机名(hostname)部分。 url.host和url.hostname之间的区别是url.hostname不 包含端口
url.href // 获取及设置序列化的URL,获取href属性的值等同于调用url.toString()。将此属性的值设置为新值等同于new URL(value)使用创建新的URL对象。URL对象的每个属性都将被修改。
url.origin // 获取只读序列化的URL origin部分
url.password // 获取及设置URL的密码(password)部分
url.pathname // 获取及设置URL的路径(path)部分
url.port // 获取及设置URL的端口(port)部分
url.protocol // 获取及设置URL的协议(protocol)部分
url.search // 获取及设置URL的序列化查询(query)部分部分
url.username // 获取及设置URL的用户名(username)部分
url.toString()

const { URL, URLSearchParams } = require('url');

const myURL = new URL('https://example.org/?abc=123');
console.log(myURL.searchParams.get('abc'));
// 输出 123

myURL.searchParams.append('abc', 'xyz');
console.log(myURL.href);
// 输出 https://example.org/?abc=123&abc=xyz

myURL.searchParams.delete('abc');
myURL.searchParams.set('a', 'b');
console.log(myURL.href);
// 输出 https://example.org/?a=b

const newSearchParams = new URLSearchParams(myURL.searchParams);
// 上面的代码等同于
// const newSearchParams = new URLSearchParams(myURL.search);

newSearchParams.append('a', 'c');
console.log(myURL.href);
// 输出 https://example.org/?a=b
console.log(newSearchParams.toString());
// 输出 a=b&a=c

// newSearchParams.toString() 被隐式调用
myURL.search = newSearchParams;
console.log(myURL.href);
// 输出 https://example.org/?a=b&a=c
newSearchParams.delete('a');
console.log(myURL.href);
// 输出 https://example.org/?a=b&a=c