nodejs个人学习笔记

柔情只为你懂 2022-06-13 07:18 333阅读 0赞

**这只是个人学习的笔记**  
**1.更新npm包**：

npm install npm -g

安装node模块语法:

npm install moduleName

**安装好的模块包都会放在node\_modules文件夹下**  
例子：  
npm install express;  
使用：  
var express = require(‘express’);  
全局安装与本地安装:

npm install express #本地安装
    npm install express -g #全局安装

如果出现以下错误：
    npm err! Error: connect ECONNREFUSED 127.0.0.1:8087
    解决办法为：
    npm config set proxy null;

本地安装
      ● 1. 将安装包放在 ./node_modules 下（运行 npm 命令时所在的目录），如果没有 node_modules 目录，会在当前执行 npm 命令的目录下生成 node_modules 目录。
      ● 2. 可以通过 require() 来引入本地安装的包。
    全局安装
      ● 1. 将安装包放在 /usr/local 下或者你 node 的安装目录。
      ● 2. 可以直接在命令行里使用。
    npm link
    npm list -g 查看全局安装的包

> npm list 模块名 查看模块的版本好

使用 package.json
    Package.json 属性说明
      ● name - 包名。
      ● version - 包的版本号。
      ● description - 包的描述。
      ● homepage - 包的官网 url 。
      ● author - 包的作者姓名。
      ● contributors - 包的其他贡献者姓名。
      ● dependencies - 依赖包列表。如果依赖包没有安装，npm 会自动将依赖包安装在 node_module 目录下。
      ● repository - 包代码存放的地方的类型，可以是 git 或 svn，git 可在 Github 上。
      ● main - main 字段是一个模块ID，它是一个指向你程序的主要项目。就是说，如果你包的名字叫 express，然后用户安装它，然后require("express")。
      ● keywords - 关键字
    npm install -g cnpm --registry=https://registry.npm.taobao.org
    npm install -g cnpm --registry=https://registry.npm.taobao.org
    cnpm install [name]

卸载模块
    npm uninstall express
    npm ls 查看模块是否存在
    更新模块
    npm update express
    搜索模块
    npm search express
    创建模块
    npm init
    $ npm adduser
    Username: mcmohd
    Password:
    Email: (this IS public) mcmohd@gmail.com
    npm publish
    在package.json所在目录下使用npm install . -g可先在本地安装当前命令行程序，可用于发布前的本地测试。
    使用npm cache clear可以清空NPM本地缓存，用于对付使用相同版本号发布新版本代码的人
    使用npm unpublish <package>@<version>可以撤销发布自己发布过的某个版本代码
    使用淘宝 NPM 镜像
    npm install -g cnpm --registry=https://registry.npm.taobao.org
    cnpm install [name]    http://npm.taobao.org/。
    
    Node.js REPL(交互式解释器)
    循环 - 循环操作以上步骤直到用户两次按下 ctrl-c 按钮退出。
    
    变量声明需要使用 var 关键字，如果没有使用 var 关键字变量会直接打印出来
    声明变量：
    var x=3 ;
    console.log(x);
    
    do{
    }while(x>5);
    下划线(_)变量
    
    你可以使用下划线(_)获取表达式的运算结果

REPL 命令
      ● ctrl + c - 退出当前终端。
      ● ctrl + c 按下两次 - 退出 Node REPL。
      ● ctrl + d - 退出 Node REPL.
      ● 向上/向下 键 - 查看输入的历史命令
      ● tab 键 - 列出当前命令
      ● .help - 列出使用命令
      ● .break - 退出多行表达式
      ● .clear - 退出多行表达式
      ● .save filename - 保存当前的 Node REPL 会话到指定文件
      ● .load filename - 载入当前 Node REPL 会话的文件内容。

Node.js 异步编程的直接体现就是回调
    Node.js 事件循环
    事件驱动程序
    在 Node 应用程序中，执行异步操作的函数将回调函数作为最后一个参数， 回调函数接收错误对象作为第一个参数。
    
    Node.js EventEmitter

Node.js里面的许多对象都会分发事件：一个net.Server对象会在每次有新连接时分发一个事件， 一个fs.readStream对象会在文件被打开的时候发出一个事件。 所有这些产生事件的对象都是 events.EventEmitter 的实例

> EventEmitter 类
> 
> 方法 序号方法 & 描述  
> **1 addListener(event, listener)**  
> 为指定事件添加一个监听器到监听器数组的尾部。  
> **2 on(event, listener)**  
> 为指定事件注册一个监听器，接受一个字符串 event  
> 和一个回调函数。server.on(‘connection’, function (stream) \{  
> console.log(‘someone connected!’); \});  
> **3 once(event, listener)**  
> 为指定事件注册一个单次监听器，即 监听器最多只会触发一次，触发后立刻解除该监听器。server.once(‘connection’,  
> function (stream) \{ console.log(‘Ah, we have our first user!’);  
> **4 removeListener(event, listener)**  
> 移除指定事件的某个监听器，监听器必须是该事件已经注册过的监听器。  
> 它接受两个参数，第一个是事件名称，第二个是回调函数名称。 var callback > = function(stream) \{  
> console.log(‘someone connected!’); \}; server.on(‘connection’,  
> callback); // … server.removeListener(‘connection’,  
> callback);  
> **5 removeAllListeners(\[event\])**  
> 移除所有事件的所有监听器，  
> **6 setMaxListeners(n)**  
> 默认情况下， EventEmitters  
> 如果你添加的监听器超过 10 个就会输出警告信息。 setMaxListeners  
> **7 listeners(event)**  
> 返回指定事件的监听器数组。  
> **8 emit(event, \[arg1\]\[arg2\], \[…\])**  
> 按参数的顺序执行每个监听器，如果事件有注册监听返回 true，否则返回 false。

var events = require("events");
    
     var evnetEmitter = new events.EventEmitter();
    
     var listener1 = function listener1(){
    
        console.log('listener1-=====');
    
     }
    
     var listener2 = function listener2(){
    
        console.log('listener2-=====');
    
     }
    
    
     evnetEmitter.addListener("connection", listener1);
    
     evnetEmitter.on('connection',listener2);
    
     var eventListeners =
     require('events').EventEmitter.listenerCount(evnetEmitter,'connection');
     console.log(eventListeners+'个监听器监听连接事件.');
    
     evnetEmitter.emit('connection');
    
     evnetEmitter.removeListener("connection", listener1);
    
     console.log("listener1 不再监听");
    
     evnetEmitter.emit('connection');
    
     eventListeners = require('events').EventEmitter.listenerCount(evnetEmitter,"connection");
    
     console.log(eventListeners + " 个监听器监听连接事件。");
    
     console.log("程序执行完毕");

继承 EventEmitter
    Node.js Buffer(缓冲区)
    创建 Buffer 类
    方法 1
    var buf = new Buffer(10);
    方法 2
    var buf = new Buffer([10, 20, 30, 40, 50]);
    方法 3
    var buf = new Buffer("www.runoob.com", "utf-8");

写入缓冲区
    语法
    写入 Node 缓冲区的语法如下所示：
    buf.write(string[, offset[, length]][, encoding])
    参数
    参数描述如下：
      ● string - 写入缓冲区的字符串。
      ● offset - 缓冲区开始写入的索引值，默认为 0 。
      ● length - 写入的字节数，默认为 buffer.length
      ● encoding - 使用的编码。默认为 'utf8' 。
    返回值
    返回实际写入的大小。如果 buffer 空间不足， 则只会写入部分字符串
    
    从缓冲区读取数据
    buf.toString([encoding[, start[, end]]])
    语法
    读取 Node 缓冲区数据的语法如下所示：
    buf.toString([encoding[, start[, end]]])
    参数
    参数描述如下：
      ● encoding - 使用的编码。默认为 'utf8' 。
      ● start - 指定开始读取的索引位置，默认为 0。
      ● end - 结束位置，默认为缓冲区的末尾。
    返回值
    解码缓冲区数据并使用指定的编码返回字符串。
    
    buf.toJSON(buf);
    缓冲区合并
    Buffer.concat(list[, totalLength])
    
    缓冲区比较
    buf.compare(otherBuffer);
    拷贝缓冲区
    var buffer1 = new Buffer('ABC');
    // 拷贝一个缓冲区
    var buffer2 = new Buffer(3);
    buffer1.copy(buffer2);
    console.log("buffer2 content: " + buffer2.toString());
    
    缓冲区裁剪
    var buffer1 = new Buffer('runoob');
    // 剪切缓冲区
    var buffer2 = buffer1.slice(0,2);
    console.log("buffer2 content: " + buffer2.toString());
    
    缓冲区长度
    buf.length

--------------------

**Node.js Stream(流)**

Readable - 可读操作。
    Writable - 可写操作。
    Duplex - 可读可写操作.
    Transform - 操作被写入数据，然后读出结果。

**所有的 Stream 对象都是 EventEmitter 的实例。常用的事件有**：  
data - 当有数据可读时触发。 end - 没有更多的数据可读时触发。  
error - 在接收和写入过程中发生错误时触发。  
finish - 所有数据已被写入到底层系统时触发读取数据 var fs = require(“fs”); var data = ”;  
**创建可读流**

> var readerStream = fs.createReadStream(‘input.txt’);

**设置编码为 utf8。**

> readerStream.setEncoding(‘UTF8’);

**处理流事件** –> data, end, and error

> readerStream.on(‘data’, function(chunk) \{ data += chunk; \});
> 
> readerStream.on(‘end’,function()\{ console.log(data); \});
> 
> readerStream.on(‘error’, function(err)\{ console.log(err.stack); \});

console.log(“程序执行完毕”);

> var fs = require(“fs”); var data = ‘www.baidu.com’;
> 
> var writeStream = fs.createWriteStream(‘input.txt’);
> 
> writeStream.write(data,’UTF8’);
> 
> writeStream.end();
> 
> writeStream.on(‘finish’,function()\{ console.log(‘write end….  
> finish’); \});
> 
> writeStream.on(‘error’,function()\{ console.log(err.stack); \});
> 
> console.log(“程序执行结束”);
> 
> var fs = require(“fs”);
> 
> var readerSream = fs.createReadStream(‘input.txt’);
> 
> var writeStream = fs.createWriteStream(‘output.txt’);
> 
> readerSream.pipe(writeStream);
> 
> console.log(“ok”);

**链式流**

var fs = require("fs");
    
    var zilb = require("zlib");
    
    fs.createReadStream("input.txt").pipe(zilb.createGzip()).pipe(fs.createWriteStream('input.txt.gz'));
    
    console.log("文件压缩完成")
    
    
    
    var fs = require("fs");
    
    var zlib = require("zlib");
    
    fs.createReadStream('input.txt.gz').pipe(zlib.createGunzip()).pipe(fs.createWriteStream('test.txt'));
    
    console.log("end")

**Node.js模块系统**

以上实例中，代码 require(‘./hello’) 引入了当前目录下的hello.js文件（./ 为当前目录，node.js默认后缀为js）。  
Node.js 提供了exports 和 require 两个对象，其中 exports 是模块公开的接口，require 用于从外部获取一个模块的接口，即所获取模块的 exports 对象

//hello.js

> function Hello() \{ var name; this.setName = function(thyName) \{  
> name = thyName; \}; this.sayHello = function() \{  
> console.log(‘Hello ’ + name); \}; \}; module.exports = Hello;

require方法接受以下几种参数的传递：  
● http、fs、path等，原生模块。  
● ./mod或../mod，相对路径的文件模块。  
● /pathtomodule/mod，绝对路径的文件模块。  
● mod，非原生模块的文件模块

> function say(word) \{ console.log(word); \}
> 
> function execute(someFunction, value) \{ someFunction(value); \}
> 
> execute(say, “Hello”);

**匿名函数**

> function execute(someFunction, value) \{ someFunction(value); \}
> 
> execute(function(word)\{ console.log(word) \}, “Hello”);

**函数传递是如何让HTTP服务器工作的**

> var http = require(“http”);
> 
> function onRequest(request, response) \{ response.writeHead(200,  
> \{“Content-Type”: “text/plain”\}); response.write(“Hello World”);  
> response.end(); \}
> 
> http.createServer(onRequest).listen(8888);

**Node.js 路由**

> function route(pathname) \{ console.log(“About to route a request for  
> ” + pathname); \}
> 
> exports.route = route;
> 
> var http = require(“http”); var url = require(“url”);
> 
> function start(route) \{ function onRequest(request, response) \{  
> var pathname = url.parse(request.url).pathname;  
> console.log(“Request for ” + pathname + ” received.”);
> 
>     route(pathname);
>     
>     response.writeHead(200, {"Content-Type": "text/plain"});
>     response.write("Hello World");
>     response.end();   }
> 
> http.createServer(onRequest).listen(8888); console.log(“Server has  
> started.”); \}
> 
> exports.start = start;
> 
> var server = require(“./server”); var router = require(“./router”);
> 
> server.start(router.route);

**Node.js 全局对象**

global 最根本的作用是作为全局变量的宿主。按照 ECMAScript 的定义，满足以下条 件的变量是全局变量：  
● 在最外层定义的变量；  
● 全局对象的属性；  
● 隐式定义的变量（未定义直接赋值的变量）。  
注意： 永远使用 var 定义变量以避免引入全局变量，因为全局变量会污染 命名空间，提高代码的耦合风险。

**\_\_filename**

> \_\_filename 表示当前正在执行的脚本的文件名。它将输出文件所在位置的绝对路径，且和命令行参数所指定的文件名不一定相同。 如果在模块中，返回的值是模块文件的路径。

**\_\_dirname**  
\_\_dirname 表示当前执行脚本所在的目录。

**setTimeout(cb, ms)**

> setTimeout(cb, ms) 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。：setTimeout() 只执行一次指定函数。  
> 返回一个代表定时器的句柄值。

**clearTimeout(t)**

> clearTimeout( t ) 全局函数用于停止一个之前通过 setTimeout() 创建的定时器。 参数 t 是通过  
> setTimeout() 函数创建的定时器。

**setInterval(cb, ms)**

> setInterval(cb, ms) 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。 返回一个代表定时器的句柄值。可以使用  
> clearInterval(t) 函数来清除定时器。 setInterval() 方法会不停地调用函数，直到 clearInterval()  
> 被调用或窗口被关闭。

**console**

> console.trace();

**process**  
**1 bort()**  
这将导致 node 触发 abort 事件。会让 node 退出并生成一个核心文件。  
**2 chdir(directory)**  
改变当前工作进程的目录，如果操作失败抛出异常。  
**3 cwd()**  
返回当前进程的工作目录  
**4 exit(\[code\])**  
使用指定的 code 结束进程。如果忽略，将会使用 code 0。  
**5 getgid()**  
获取进程的群组标识（参见 getgid(2)）。获取到得时群组的数字 id，而不是名字。  
注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。  
**6 setgid(id)**  
设置进程的群组标识（参见 setgid(2)）。可以接收数字 ID 或者群组名。如果指定了群组名，会阻塞等待解析为数字 ID 。  
注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。  
**7 getuid()**  
获取进程的用户标识(参见 getuid(2))。这是数字的用户 id，不是用户名。  
注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。  
**8 setuid(id)**  
设置进程的用户标识（参见setuid(2)）。接收数字 ID或字符串名字。果指定了群组名，会阻塞等待解析为数字 ID 。  
注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。  
**9 getgroups()**  
返回进程的群组 iD 数组。POSIX 系统没有保证一定有，但是 node.js 保证有。  
注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。  
**10 setgroups(groups)**  
设置进程的群组 ID。这是授权操作，所有你需要有 root 权限，或者有 CAP\_SETGID 能力。  
注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。  
**11 initgroups(user, extra\_group)**  
读取 /etc/group ，并初始化群组访问列表，使用成员所在的所有群组。这是授权操作，所有你需要有 root 权限，或者有 CAP\_SETGID 能力。  
注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。  
**12 kill(pid\[, signal\])**  
发送信号给进程. pid 是进程id，并且 signal 是发送的信号的字符串描述。信号名是字符串，比如 ‘SIGINT’ 或 ‘SIGHUP’。如果忽略，信号会是 ‘SIGTERM’。  
**13 memoryUsage()**  
返回一个对象，描述了 Node 进程所用的内存状况，单位为字节。  
**14 nextTick(callback)**  
一旦当前事件循环结束，调用回到函数。  
**15 umask(\[mask\])**  
设置或读取进程文件的掩码。子进程从父进程继承掩码。如果mask 参数有效，返回旧的掩码。否则，返回当前掩码。  
**16 uptime()**  
返回 Node 已经运行的秒数。  
**17 hrtime()**  
返回当前进程的高分辨时间，形式为 \[seconds, nanoseconds\]数组。它是相对于过去的任意事件。该值与日期无关，因此不受时钟漂移的影响。主要用途是可以通过精确的时间间隔，来衡量程序的性能。  
你可以将之前的结果传递给当前的 process.hrtime() ，会返回两者间的时间差，用来基准和测量时间间隔

**Node.js 常用工具**

util.inherits(constructor, superConstructor)是一个实现对象间原型继承 的函数
    
    
    util.inspect
    
    Sub 仅仅继承了Base 在原型中定义的函数，而构造函数内部创造的 base 属 性和 sayHello 函数都没有被 Sub 继承。
    同时，在原型中定义的属性不会被console.log 作 为对象的属性输出。如果我们去掉 objSub.sayHello(); 这行的注释，将会看到：
    
    
    util.inspect
    util.inspect(object,[showHidden],[depth],[colors])是一个将任意对象转换 为字符串的方法，通常用于调试和错误输出。它至少接受一个参数 object，即要转换的对象。
    
    
    util.isArray(object)
    
    如果给定的参数 "object" 是一个数组返回true，否则返回false。
    
    util.isRegExp(object)
    
    util.isDate(object)
    
    util.isError(object)

**Node.js 文件系统**

Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 fs.readFile() 和同步的 fs.readFileSync()

fs.open(path, flags[, mode], callback)
    
    fs.stat(path, callback)
    
    fs.read(fd, buffer, offset, length, position, callback)
    
    fs.close(fd, callback)
    
    截取文件
    fs.ftruncate(fd, len, callback)
    
    
    删除文件
    fs.unlink(path, callback)
    
    创建目录
    fs.mkdir(path[, mode], callback)
    
    读取目录
    fs.readdir(path, callback)
    
    删除目录
    fs.rmdir(path,callback)

获取GET请求内容
    var http = require('http');
    var url = require('url');
    var util = require('util');
    
    http.createServer(function(req, res){ 
        res.writeHead(200, {
       'Content-Type': 'text/plain; charset=utf-8'});
        res.end(util.inspect(url.parse(req.url, true)));
    }).listen(3000);

var http = require('http');
    var url = require('url');
    var util = require('util');
    
    http.createServer(function(req, res){ 
        res.writeHead(200, {
       'Content-Type': 'text/plain'});
    
        // 解析 url 参数
        var params = url.parse(req.url, true).query;
        res.write("网站名：" + params.name);
        res.write("\n");
        res.write("网站 URL：" + params.url);
        res.end();
    
        }).listen(3000);

**Node.js Net 模块**

**1 net.createServer(\[options\]\[, connectionListener\])**  
创建一个 TCP 服务器。参数 connectionListener 自动给 ‘connection’ 事件创建监听器。  
**2 net.connect(options\[, connectionListener\])**  
返回一个新的 ‘net.Socket’，并连接到指定的地址和端口。  
当 socket 建立的时候，将会触发 ‘connect’ 事件。  
**3 net.createConnection(options\[, connectionListener\])**  
创建一个到端口 port 和 主机 host的 TCP 连接。 host 默认为 ‘localhost’。  
**4 net.connect(port\[, host\]\[, connectListener\])**  
创建一个端口为 port 和主机为 host的 TCP 连接 。host 默认为 ‘localhost’。参数 connectListener 将会作为监听器添加到 ‘connect’ 事件。返回 ‘net.Socket’。  
**5 net.createConnection(port\[, host\]\[, connectListener\])**  
创建一个端口为 port 和主机为 host的 TCP 连接 。host 默认为 ‘localhost’。参数 connectListener 将会作为监听器添加到 ‘connect’ 事件。返回 ‘net.Socket’。  
**6 net.connect(path\[, connectListener\])**  
创建连接到 path 的 unix socket 。参数 connectListener 将会作为监听器添加到 ‘connect’ 事件上。返回 ‘net.Socket’。  
**7 net.createConnection(path\[, connectListener\])**  
创建连接到 path 的 unix socket 。参数 connectListener 将会作为监听器添加到 ‘connect’ 事件。返回 ‘net.Socket’。  
**8 net.isIP(input)**  
检测输入的是否为 IP 地址。 IPV4 返回 4， IPV6 返回 6，其他情况返回 0。  
**9 net.isIPv4(input)**  
如果输入的地址为 IPV4， 返回 true，否则返回 false。  
**10 net.isIPv6(input)**  
如果输入的地址为 IPV6， 返回 true，否则返回 false。

**net.Server**

**1 server.listen(port\[, host\]\[, backlog\]\[, callback\])**  
监听指定端口 port 和 主机 host ac连接。 默认情况下 host 接受任何 IPv4 地址(INADDR\_ANY)的直接连接。端口 port 为 0 时，则会分配一个随机端口。

**2 server.listen(path\[, callback\])**  
通过指定 path 的连接，启动一个本地 socket 服务器。  
**3 server.listen(handle\[, callback\])**  
通过指定句柄连接。  
**4 server.listen(options\[, callback\])**  
options 的属性：端口 port, 主机 host, 和 backlog, 以及可选参数 callback 函数, 他们在一起调用server.listen(port, \[host\], \[backlog\], \[callback\])。还有，参数 path 可以用来指定 UNIX socket。  
**5 server.close(\[callback\])**  
服务器停止接收新的连接，保持现有连接。这是异步函数，当所有连接结束的时候服务器会关闭，并会触发 ‘close’ 事件。  
**6 server.address()**  
操作系统返回绑定的地址，协议族名和服务器端口。  
**7 server.unref()**  
如果这是事件系统中唯一一个活动的服务器，调用 unref 将允许程序退出。  
**8 server.ref()**  
与 unref 相反，如果这是唯一的服务器，在之前被 unref 了的服务器上调用 ref 将不会让程序退出（默认行为）。如果服务器已经被 ref，则再次调用 ref 并不会产生影响。  
***9 server.getConnections(callback)***  
异步获取服务器当前活跃连接的数量。当 socket 发送给子进程后才有效；回调函数有 2 个参数 err 和 count。

**事件**  
**1 listening**  
当服务器调用 server.listen 绑定后会触发。  
**2 connection**  
当新连接创建后会被触发。socket 是 net.Socket实例。  
**3 close**  
服务器关闭时会触发。注意，如果存在连接，这个事件不会被触发直到所有的连接关闭。  
**4 error**  
发生错误时触发。’close’ 事件将被下列事件直接调用。

**net.Socket**

net.Socket 对象是 TCP 或 UNIX Socket 的抽象。net.Socket 实例实现了一个双工流接口。 他们可以在用户创建客户端(使用 connect())时使用, 或者由 Node 创建它们，并通过 connection 服务器事件传递给用户。

**1 lookup**  
在解析域名后，但在连接前，触发这个事件。对 UNIX sokcet 不适用。

**2.connect**  
成功建立 socket 连接时触发。  
**3 data**  
当接收到数据时触发。  
**4 end**  
当 socket 另一端发送 FIN 包时，触发该事件。  
**5 timeout**  
当 socket 空闲超时时触发，仅是表明 socket 已经空闲。用户必须手动关闭连接。  
**6 drain**  
当写缓存为空得时候触发。可用来控制上传。  
**7 error**  
错误发生时触发。  
**8 close**  
当 socket 完全关闭时触发。参数 had\_error 是布尔值，它表示是否因为传输错误导致 socket 关闭。

**属性**

**1 socket.bufferSize**  
该属性显示了要写入缓冲区的字节数。  
**2 socket.remoteAddress**  
远程的 IP 地址字符串，例如：’74.125.127.100’ or ‘2001:4860:a005::68’。  
**3 socket.remoteFamily**  
远程IP协议族字符串，比如 ‘IPv4’ or ‘IPv6’。  
**4 socket.remotePort**  
远程端口，数字表示，例如：80 or 21。  
**5 socket.localAddress**  
网络连接绑定的本地接口 远程客户端正在连接的本地 IP 地址，字符串表示。例如，如果你在监听’0.0.0.0’而客户端连接在’192.168.1.1’，这个值就会是 ‘192.168.1.1’。  
**6 socket.localPort**  
本地端口地址，数字表示。例如：80 or 21。  
**7 socket.bytesRead**  
接收到得字节数。  
**8 socket.bytesWritten**  
发送的字节数。

**Node.js DNS**  
**Node.js Domain 模块**  
Node.js Domain(域) 简化异步代码的异常处理，可以捕捉处理try catch无法捕捉的异常。引入 Domain 模块 语法格式如下：

> var domain = require(“domain”)
> 
> web cat server.js var http = require(“http”);
> 
> var fs = require(“fs”);
> 
> var url = require(“url”);
> 
> http.createServer(function(request,response)\{ var pathname =  
> url.parse(request.url).pathname; console.log(“Request for”+pathname+”  
> received”); fs.readFile(pathname.substr(1),function(err,data)\{  
> if(err)\{ console.log(err);  
> response.writeHead(404,\{‘Content-Type’:’text/html’\}); \}else\{
> 
> response.writeHead(200,\{‘Content-Type’:’text/html’\});
> 
> response.write(data.toString()); \}
> 
> response.end();
> 
> \}); \}).listen(8888);
> 
> console.log(“Server is running at [http://127.0.0.1:8888][http_127.0.0.1_8888]“)
> 
> cat client.js var http = require(“http”);
> 
> var options = \{ host:’localhost’, port:’8888’, path:”/index.htm”
> 
> \};
> 
> var callback = function(response)\{
> 
> var body = ”;
> 
> response.on(‘data’,function(data)\{ body +=data;
> 
> \});
> 
> response.on(‘end’,function()\{ console.log(body); \});
> 
> \};
> 
> var req = http.request(options,callback); req.end();

**Node.js Express 框架**

**yield 表达式**

由于 Generator 函数返回的遍历器对象，只有调用next方法才会遍历下一个内部状态，所以其实提供了一种可以暂停执行的函数。yield表达式就是暂停标志。
    遍历器对象的next方法的运行逻辑如下。
    （1）遇到yield表达式，就暂停执行后面的操作，并将紧跟在yield后面的那个表达式的值，作为返回的对象的value属性值。
    （2）下一次调用next方法时，再继续往下执行，直到遇到下一个yield表达式。
    （3）如果没有再遇到新的yield表达式，就一直运行到函数结束，直到return语句为止，并将return语句后面的表达式的值，作为返回的对象的value属性值。
    （4）如果该函数没有return语句，则返回的对象的value属性值为undefined。

[http_127.0.0.1_8888]: http://127.0.0.1:8888