A. 如何编译nodejs的二进制模块
god Buffer类是一个全局的直接处理二进制数据类型。它可以以各种方式构造。 look
sex 纯javascript对于Unicode的处理是友好的，而对二进制并不友好。但处理TCP数据流和文件系统，必须要处理字节流，所以node.js提供一套策略来创建和操作字节流。 sex
googog 数据储存在一个Buffer实例中，一个Buffer的大小是固定的，类似于不可变的整数数组。 good
look Buffer与字符串之间的转换需要指定明确的编码。 googog
this Buffer支持的编码： book
yellow 'ascii'编码，只为7位的ASCII的数据。这个编码方法非常快！ googog
god 'utf8' 编码，支持Unicode字符。 yellow
yellow 'utf16le' 编码，小端编码的Unicode字符。对（u10000 ~ u10FFFF）的支持。 fuck
book 'ucs2' 是 'utf16le' 编码的别名。 god
look 'base64' 是 Base64字符串编码。 this
good 'hex' 表示十六进制编码，每个byte编码为两个十六进制字符。 look
sex 一个Buffer对象也可以使用一个类型数组。Buffer对象克隆到一个ArrayBuffer，用作类型数组存储支持。node.js提供的Buffer和标准类型化数组是两套不同的系统，所以Buffer和ArrayBuffer的内存不共享。 sex
sex 注意：虽然V8提供了标准化的类型化数组，但node.js自身定义的Buffer提供了更灵活强大的API，在之后的章节会详细讲解两者的转换与使用方法。 good
B. nodejs编译后js文件名前缀
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。
Node与javaScript的区别在于，javaScript的顶层对象是window,而node是global
//这里使用的var声明的变量不是全局的，是当前模块下的，用global声明的表示是全局的
var s = 100;
global.s = 200;
//这里访问到的s是var生命的
console.log(s); //100
//这里访问到的才是全局变量
console.log(global.s); //200
模块：在node中，文件和模块是一一对应的，也就是一个文件就是一个模块；每个模块都有自己的作用域，我们通过var申明的变量并非全局而是该模块作用域下的。
（2）mole模块
1、文件查找
1）首先按照加载的模块的文件名称进行查找，如果没有找到，则会带上 .js、.json 或 .node 拓展名在加载
2）以 '/' 为前缀的模块是文件的绝对路径。 例如，require('/home/marco/foo.js') 会加载 /home/marco/foo.js 文件。
3）以 './' 为前缀的模块是相对于调用 require() 的文件的。 也就是说，circle.js 必须和 foo.js 在同一目录下以便于 require('./circle') 找到它。
4）当没有以 '/'、'./' 或 '../' 开头来表示文件时，这个模块必须是一个核心模块或加载自 node_moles 目录。
5）如果给定的路径不存在，则 require() 会抛出一个 code 属性为 'MODULE_NOT_FOUND' 的 Error。
2、mole 作用域
在一个模块中通过var定义的变量，其作用域范围是当前模块，外部不能够直接的访问，如果我们想一个模块能够访问另外一个模块中定义的变量，可以有一下两种方式：
1）把变量作为global对象的一个属性，但这样的做法是不推荐的
2）使用模块对象 mole。mole保存提供和当前模块有关的一些信息。
在这个mole对象中有一个子对象exports对象，我们可以通过这个对象把一个模块中的局部变量对象进行提供访问。
//这个方法的返回值，其实就是被加载模块中的mole.exports
require('./02.js');
3、__dirname：当前模块的目录名。
例子，在 /Users/mjr 目录下运行 node example.js：
console.log(__dirname);
// 输出: /Users/mjr
console.log(path.dirname(__filename));
// 输出: /Users/mjr
4、__filename：当前模块的文件名（处理后的绝对路径）。当前模块的目录名可以使用 __dirname 获取。
在 /Users/mjr 目录下运行 node example.js：
console.log(__filename);
// 输出: /Users/mjr/example.js
console.log(__dirname);
// 输出: /Users/mjr
（3）process（进程）
process 对象是一个全局变量，提供 Node.js 进程的有关信息以及控制进程。 因为是全局变量，所以无需使用 require()。
1、process.argv
返回进程启动时的命令行参数。第一个元素是process.execPath。第二个元素是当前执行的JavaScript文件的路径。剩余的元素都是额外的命令行参数。
console.log(process.argv);
打印结果：
2、process.execPath返回启动进程的可执行文件的绝对路径。
3、process.env 返回用户的环境信息。
在process.env中可以新增属性：
process.env.foo = 'bar';
console.log(process.env.foo);
可以通过delete删除属性：
delete process.env.foo;
console.log(process.env);
在Windows上，环境变量不区分大小写
4、process.pid 属性返回进程的PID。
5、process.platform属性返回字符串，标识Node.js进程运行其上的操作系统平台。
6、process.title 属性用于获取或设置当前进程在 ps 命令中显示的进程名字
7、process.uptime() 方法返回当前 Node.js 进程运行时间秒长
注意: 该返回值包含秒的分数。 使用 Math.floor() 来得到整秒钟。
8、process.versions属性返回一个对象，此对象列出了Node.js和其依赖的版本信息。
process.versions.moles表明了当前ABI版本，此版本会随着一个C++API变化而增加。 Node.js会拒绝加载模块，如果这些模块使用一个不同ABI版本的模块进行编译。
9、process对象-输入输出流
var a;
var b;
process.stdout.write('请输入a的值: ');
process.stdin.on('data', (chunk) => {
if (!a) {
a = Number(chunk);
process.stdout.write('请输入b的值:');
}else{
b = Number(chunk);
process.stdout.write('a+b的值:'+(a+b));
process.exit();
}
});
（4）Buffer缓冲器
Buffer类，一个用于更好的操作二进制数据的类，我们在操作文件或者网络数据的时候，其实操作的就是二进制数据流，Node为我们提供了一个更加方便的去操作这种数据流的类Buffer,他是一个全局的类
1、如何创建使用buffer
Buffer.from(array) 返回一个 Buffer，包含传入的字节数组的拷贝。
Buffer.from(arrayBuffer[, byteOffset [, length]]) 返回一个 Buffer，与传入的 ArrayBuffer 共享内存。
Buffer.from(buffer) 返回一个 Buffer，包含传入的 Buffer 的内容的拷贝。
Buffer.from(string[, encoding]) 返回一个 Buffer，包含传入的字符串的拷贝。
Buffer.alloc(size[, fill[, encoding]]) 返回一个指定大小且已初始化的 Buffer。 该方法比 Buffer.allocUnsafe(size) 慢，但能确保新创建的 Buffer 不会包含旧数据。
Buffer.allocUnsafe(size) 与 Buffer.allocUnsafeSlow(size) 返回一个指定大小但未初始化的 Buffer。 因为 Buffer 是未初始化的，可能包含旧数据。
// 创建一个长度为 10、且用 01 填充的 Buffer。
const buf1 = Buffer.alloc(10,1);
// 创建一个长度为 10、且未初始化的 Buffer。
// 这个方法比调用 Buffer.alloc() 更快，但返回的 Buffer 实例可能包含旧数据，因此需要使用 fill() 或 write() 重写。
const buf2 = Buffer.allocUnsafe(10);
const buf3 = Buffer.from([1, 2, 3]);
const buf4 = Buffer.from('tést');
console.log(buf1); //<Buffer 01 01 01 01 01 01 01 01 01 01>
console.log(buf2); //<Buffer 00 00 00 00 08 00 00 00 07 00>
console.log(buf3); //<Buffer 01 02 03>
console.log(buf4); //<Buffer 74 c3 a9 73 74>
2、Buffer对象提供的toString、JSON的使用
1）buf.toString(encoding，start，end)
var bf = Buffer.from('miaov');
console.log(bf.toString('utf-8',1,4)); //iaov
console.log(bf.toString('utf-8',0,5)); //miaov
console.log(bf.toString('utf-8',0,6)); //miaov
2）buf.write(string，offset，length，encoding)
string 要写入 buf 的字符串。
offset 开始写入的偏移量。默认 0，这里指的是buffer对象的起始要写入的位置。
length 要写入的字节数。默认为 buf.length - offset。
encoding string 的字符编码。默认为 'utf8'。
返回: 已写入的字节数。
var str = "miaov hello";
var bf = Buffer.from(str);
var bf2 = Buffer.alloc(8);
//从0开始写入5个
bf2.write(str,0,5);
console.log(bf);
console.log(bf2);
3）buf.toJSON()
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);
console.log(json);
// 输出: {"type":"Buffer","data":[1,2,3,4,5]}
3、Buffer中静态方法的使用
1）Buffer.isEncoding(encoding) ： 判断是否是Buffer支持的字符编码，是则返回true，不是则返回false
console.log(Buffer.isEncoding('utf-8')); //true
2）Buffer.isBuffer(obj) ：如果 obj 是一个 Buffer，则返回 true，否则返回 false。
（5）fs（文件系统）
该模块是核心模块，需要使用require('fs')导入后使用，该模块主要用来操作文件
1、fs.open(path, flags, mode, callback)
path：要打开的文件的路径；
flags：打开文件的方式 读/写；
mode：设置文件的模式 读/写/执行
callback(err，fd)：文件打开以后，在回调函数中做相应的处理,回调函数的两个参数：
err：文件打开失败的错误保存在err里面，如果成功err为null
fd：被打开文件的标识
var fs = require('fs');
fs.open('./test.txt','r',function(err,fd){
if(err){
console.log("文件打开失败");
}else{
console.log("文件打开成功");
}
});
2、fs.openSync(path, flags, mode) ：返回文件描述符。
var fs = require('fs');
console.log(fs.openSync('./test.txt','r')); //3
3、fs.read(fd, buffer, offset, length, position, callback)
从 fd 指定的文件中读取数据；
buffer 指定要写入数据的 buffer；
offset 指定 buffer 中开始写入的偏移量；
length 指定要读取的字节数；
position 指定文件中开始读取的偏移量。 如果 position 为 null，则从文件的当前位置开始读取；
callback 有三个参数 (err, bytesRead, buffer)
示例：test.txt 中的值为123456789
fs.open('./test.txt','r',function(err,fd){
if(!err){
var bf = Buffer.alloc(5);
fs.read(fd,bf,0,5,0,function(){
console.log(bf.toString()); //12345
})
}
});
4、fs.write(fd, buffer, offset, length, position, callback)
将 buffer 写入到 fd 指定的文件。
offset 指定 buffer 中要开始被写入的偏移量，length 指定要写入的字节数。
position 指定文件中要开始写入的偏移量。 如果 typeof position !== 'number'，则从当前位置开始写入。
callback 有三个参数 (err, bytesWritten, buffer)，其中 bytesWritten 指定 buffer 中已写入文件的字节数。
var fs = require('fs');
fs.open('./test.txt','r+',function(err,fd){
if(!err){
var bf = Buffer.alloc(5);
fs.read(fd,bf,0,5,0,function(){
console.log(bf.toString()); //12345
});
var bf = Buffer.from('test数据');
fs.write(fd,bf,0,10,0);
fs.write(fd,'测试数据2',10,'utf-8');
}
});
fs.write(fd, string, position, encoding, callback)
将 string 写入到 fd 指定的文件。 如果 string 不是一个字符串，则会强制转换成字符串。
position 指定文件中要开始写入的偏移量。 如果 typeof position !== 'number'，则从当前位置开始写入。
encoding 指定字符串的编码。
callback 有三个参数 (err, written, string)，其中 written 指定字符串中已写入文件的字节数。 写入的字节数与字符串的字符数是不同的。
5、fs.exists(path,callback)检查指定路径的文件或者目录是否存在
fs.appendFile(path, data, callback)：将数据追加到文件，如果文件不存在则创建文件。
//检查文件是否存在
var fs = require('fs');
var filename = './test2.txt';
fs.exists(filename,function(isExists){
if(!isExists){
fs.writeFile(filename,'miaov',function(err){
if(err){
console.log("文件创建失败");
}else{
console.log("文件创建成功");
}
});
}else{
fs.appendFile(filename,'-leo',function(err){
if(err){
console.log("文件内容追加失败");
}else{
console.log("文件内容追加成功");
}
})
}
});
（6）前端项目自动化构建
1、创建myProject项目文件以及对应的文件夹
var projectData ={
'name':'myProject',
'fileData':[
{
'name':'css',
'type':'dir'
},{
'name':'js',
'type':'dir'
},{
'name':'images',
'type':'dir'
},{
'name':'index.html',
'type':'file',
'content' : '<html>\n\t<head>\n\t\t<title>title</title>\n\t</head>\n\t<body>\n\t\t<h1>Hello</h1>\n\t</body>\n</html>'
}
]
};
var fs = require('fs');
if(projectData.name){
// 创建项目文件夹
fs.mkdirSync(projectData.name);
var fileData = projectData.fileData;
if(fileData && fileData.length){
fileData.forEach(function(file){
//文件或文件夹路径
file.path = './'+projectData.name +'/'+ file.name;
//根据type类型创建文件或文件夹
file.content = file.content || '';
switch(file.type){
case 'dir':
fs.mkdirSync(file.path);
break;
case 'file':
fs.writeFileSync(file.path,file.content);
break;
default:
break;
}
});
}
}
2、自动打包多个文件
var fs = require('fs');
var filedir = './myProject/dist';
fs.exists(filedir,function(isExists){
if(!isExists){
fs.mkdirSync(filedir);
}
fs.watch(filedir,function(ev,file){
//只要有一个文件发生了变化，我们就需要对文件夹下的所有文件进行读取、合并
fs.readdir(filedir,function(err,dataList){
var arr = [];
dataList.forEach(function(file){
if(file){
//statSync查看文件属性
var info = fs.statSync(filedir + '/' +file);
//mode文件权限
if(info.mode === 33206){
arr.push(filedir + '/' +file);
}
}
});
//读取数组中的文件内容
var content = '';
arr.forEach(function(file){
var c = fs.readFileSync(file);
content += c.toString()+'\n';
});
//合并文件中的内容
fs.writeFileSync('./myProject/js/index.js',content);
})
});
});
（7）使用node进行web开发
1、搭建一个http的服务器，用于处理用户发送的http请求
//加载一个http模块
var http = require('http');
//通过http模块下的createServer创建并返回一个web服务器对象
var server = http.createServer();
//开启 HTTP 服务器监听连接，只有调用了listen方法以后，服务器才开始工作
server.listen(8000,'localhost');
//服务器是否正在监听连接
server.on('listening',function(){
console.log("listening..........");
});
//每次接收到一个请求时触发，每个连接可能有多个请求（在 HTTP keep-alive 连接的情况下）。
server.on('request',function(){
res.write('<p>hello</p>');
res.end();
});
2、request方法有两个参数：request、response
1）request：http.IncomingMessage的一个实例，获取请求的一些信息，如头信息，数据等
httpVession：使用的http协议的版本
headers：请求头信息中的数据
url：请求的地址
method：请求的方式
2）response：http.ServerResponse的一个实例，可以向请求的客户端输出返回响应
write（chunk,encoding）：发送一个数据块到相应正文中
end（chunk,encoding）：当所有的正文和头信息发送完成以后调用该方法告诉服务器数据已经全部发送完成了，这个方法在每次完成信息发送以后必须调用，并且是最后调用。
statusCode：该属性用来设置返回的状态码
setHeader（name,value）：设置返回头信息
writeHead（statusCode,reasonPhrase,headers）这个方法只能在当前请求中使用一次，并且必须在response.end（）之前调用
3、使用fs模块实现行为表现分离
var http = require('http');
var url = require('url');
var fs = require('fs');
var server = http.createServer();
//html文件的路径
var htmlDir = __dirname + '/html/';
server.on('request',function(request,response){
var urlStr = url.parse(request.url);
//根据pathname匹配对应的html文件
switch(urlStr.pathname){
case '/':
sendData(htmlDir + 'index.html',request,response);
break;
case '/user':
sendData(htmlDir + 'user.html',request,response);
break;
case '/login':
sendData(htmlDir + 'login.html',request,response);
break;
default:
//处理其他情况
sendData(htmlDir + 'err.html',request,response );
break;
}
});
function sendData(file,request,response){
//读取文件，存在则返回对应读取的内容，不存在则返回错误信息
fs.readFile(file,function(err,data){
if(err){
response.writeHead(404,{
'content-type':'text/html;charset=utf-8'
});
response.end('<h1>页面不存在</h1>')
}else{
response.writeHead(200,{
'content-type':'text/html;charset=utf-8'
});
response.end(data);
}
})
}
server.listen(8000,'localhost');
C. nodejs socket怎么主动刷新缓存区数据
清空socket缓存区的数据的方法
由于socket是以数据流的形式发送数据，接收方不知道对方一次性发送了多少数据，也能保证对方一次性发送的数据能在同一刻接收到，所以Receive方法是这么工作的：
接受一个byye[]类型的参数作为缓冲区，在经过一定的时间后把接收到的数据填充到这个缓冲区里面，并且返回实际接收到数据的长度，这个实际接收到的数据长度有可能为0（没有接收到数据）、大于0小于缓冲区的长度（接收到数据，但是没有我们预期的多）、等于缓冲区的长度（说明接收到的数据大于等于我们预期的长度）。
每次接收缓冲区都用同一个byte[] byteMessage，并且你没有检查接收到的数据长度，所以第一次你接收到的数据是123456，第二次你只接收到了8，但是缓冲区里面还有23456，所以加起来就是823456了。
socket接收缓冲区的大小有讲究，设置大了接收起来慢，因为它要等尽可能多的数据接收到了再返回；设置小了需要重复多次调用接收方法才能把数据接收完，socket有个属性，标识了系统默认的接收缓冲区大小，可以参考这个！
还有就是用recv读取，但是由于不知道缓存里有多少数据，如果是阻塞模式，到最后必然等到超时才知道数据已经读取完毕，这是个问题。
另一个是用fgetc，通过返回判断是否是feof：
whlie （1） { a=fgetc（f）；if （feof（f）） break；//…
b=fgetc（f）；if （feof（f）） break；//…}当然，我不知道读取完毕后最后一次调用fgetc会不会堵塞，需要测试。
在非阻塞模式下，我们用recv就可以轻松搞定了，但是阻塞模式下，由于我们不知道缓冲区有多少数据，不能直接调用recv尝试清除。
使用一个小小的技巧，利用select函数，我们可以轻松搞定这个问题：
select函数用于监视一个文件描述符集合，如果集合中的描述符没有变化，则一直阻塞在这里，直到超时时间到达；在超时时间内，一旦某个描述符触发了你所关心的事件，select立即返回，通过检索文件描述符集合处理相应事件；select函数出错则返回小于零的值，如果有事件触发，则返回触发事件的描述符个数；如果超时，返回0，即没有数据可读。
重点在于：我们可以用select的超时特性，将超时时间设置为0，通过检测select的返回值，就可以判断缓冲是否被清空。通过这个技巧，使一个阻塞的socket成了‘非阻塞’socket.
现在就可以得出解决方案了：使用select函数来监视要清空的socket描述符，并把超时时间设置为0，每次读取一个字节然后丢弃（或者按照业务需要进行处理，随你便了），一旦select返回0，说明缓冲区没数据了（“超时”了）。
D. 谁能将这段nodejs代码翻译成java代码
Stringsk="xxx";
KeyGeneratorgenerator=KeyGenerator.getInstance(“HmacSHA256”);
SecretKeykey=generator.generateKey();
Macmac=Mac.getInstance(key.getAlgorithm());
mac.init(key);
byte[]bytes=mac.doFinal(str.getBytes());
StringBuffersb=newStringBuffer();
for(inti=0;i<bytes.length;i++){
intt=bytes[i];
sb.append(Integer.toString(t>>4&0xF,16)).append(
Integer.toString(t&0xF,16));
}
Stringsignature=sb.toString();
E. 求教nodejs怎么对密码进行加盐的hash加密
nodejs怎么对密码进行加盐的hash加密？
以前java项目最近打算用node.js重写，但是加密这里实在没搞定。java中加密是：1024次加盐sha-1加密，
一个例子：salt：47998d63768aa877，密文：，明文：yunstudio2013
下面是java代码：
private static byte[] digest(byte[] input, String algorithm, byte[] salt, int iterations) {
try {
MessageDigest digest = MessageDigest.getInstance(algorithm);
if (salt != null) {
digest.update(salt);
}
byte[] result = digest.digest(input);
for (int i = 1; i < iterations; i++) {
digest.reset();
result = digest.digest(result);
}
return result;
} catch (GeneralSecurityException e) {
throw Exceptions.unchecked(e);
}
}
我在js里面是这么干的，但是结果一直不对，代码如下：
//
var hash = crypto.createHmac("sha1", “47998d63768aa877”).update(“yunstudio2013”).digest(“hex”);
for (var i = 1; i < 1024; i++) {
hash = crypto.createHmac("sha1", “47998d63768aa877”).update(hash).digest(“hex”);
console.log(hash);
}
F. 字节跳动转用nodejs
是。根据查询字节跳动软件消息显示，转用是nodejs。Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。 Node.js 使用了一个事件驱动、非阻塞式 I/O 的模型。
G. 下面的java 加密用nodejs该怎么实现谢谢
说说个人的看法，仅供参考。
我们可以把java的接口进一步封装成一个服务，例如rest风格的接口，然后nodejs进行调用，数据封装使用Json，也是一种解决思路。
H. 如何使用 NodeJS 将文件或图像上传到服务器
下面先介绍上传文件到服务器（多文件上传）：
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.util.regex.*;
import org.apache.commons.fileupload.*;
public class upload extends HttpServlet {
private static final String CONTENT_TYPE = "text/html; charset=GB2312";
//Process the HTTP Post request
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType(CONTENT_TYPE);
PrintWriter out=response.getWriter();
try {
DiskFileUpload fu = new DiskFileUpload();
// 设置允许用户上传文件大小,单位:字节，这里设为2m
fu.setSizeMax(2*1024*1024);
// 设置最多只允许在内存中存储的数据,单位:字节
fu.setSizeThreshold(4096);
// 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
fu.setRepositoryPath("c://windows//temp");
//开始读取上传信息
List fileItems = fu.parseRequest(request);
// 依次处理每个上传的文件
Iterator iter = fileItems.iterator();
//正则匹配，过滤路径取文件名
String regExp=".+////(.+)$";
//过滤掉的文件类型
String[] errorType={".exe",".com",".cgi",".asp"};
Pattern p = Pattern.compile(regExp);
while (iter.hasNext()) {
FileItem item = (FileItem)iter.next();
//忽略其他不是文件域的所有表单信息
if (!item.isFormField()) {
String name = item.getName();
long size = item.getSize();
if((name==null||name.equals("")) && size==0)
continue;
Matcher m = p.matcher(name);
boolean result = m.find();
if (result){
for (int temp=0;temp<ERRORTYPE.LENGTH;TEMP++){
if (m.group(1).endsWith(errorType[temp])){
throw new IOException(name+": wrong type");
}
}
try{
//保存上传的文件到指定的目录
//在下文中上传文件至数据库时，将对这里改写
item.write(new File("d://" + m.group(1)));
out.print(name+" "+size+"");
}
catch(Exception e){
out.println(e);
}
}
else
{
throw new IOException("fail to upload");
}
}
}
}
catch (IOException e){
out.println(e);
}
catch (FileUploadException e){
out.println(e);
}
}
}
现在介绍上传文件到服务器，下面只写出相关代码：
以sql2000为例，表结构如下：
字段名：name filecode
类型： varchar image
数据库插入代码为：PreparedStatement pstmt=conn.prepareStatement("insert into test values(?,?)");
代码如下：
。。。。。。
try{
这段代码如果不去掉，将一同写入到服务器中
//item.write(new File("d://" + m.group(1)));
int byteread=0;
//读取输入流，也就是上传的文件内容
InputStream inStream=item.getInputStream();
pstmt.setString(1,m.group(1));
pstmt.setBinaryStream(2,inStream,(int)size);
pstmt.executeUpdate();
inStream.close();
out.println(name+" "+size+" ");
}
。。。。。。
这样就实现了上传文件至数据库
I. nodejs 承载 多少 websocket
首先是协议的升级，这个比较简单，就简述一下：当在客户端执行new
Websocket("ws://XXX.com/")的时候，客户端就会发起请求报文进行握手申请，报文中有个很重要的key就是Sec-
WebSocket-Key，服务端获取到key，然后将这个key与字符串258EAFA5-E914-47DA-95CA-C5AB0DC85B11
相连，对新的字符串通过sha1安全散列算法计算出结果后，再进行base64编码，并且将结果放在请求头的"Sec-WebSocket-
Accept"中返回即可完成握手。具体请看代码：
server.on('upgrade', function (req, socket, upgradeHead) {
var key = req.headers['sec-websocket-key'];
key = crypto.createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64");
var headers = [
'HTTP/1.1 101 Switching Protocols',
'Upgrade: websocket',
'Connection: Upgrade',
'Sec-WebSocket-Accept: ' + key
];
socket.setNoDelay(true);
socket.write(headers.join("\r\n") + "\r\n\r\n", 'ascii');
var ws = new WebSocket(socket);
webSocketCollector.push(ws);
callback(ws);
});
upgrade事件其实是http这个模块的封装，再往底层就是net模块的实现，其实都差不多，如果直接用net模块来实现的话，就是监听net.createServer返回的server对象的data事件，接收到的第一份数据就是客户端发来的升级请求报文。
上面那段代码就完成了websocket的握手，然后就可以开始数据传输了。
看数据传输之前，先看看websocket数据帧的定义（因为觉得深入浅出nodejs里的帧定义图最容易理解，所以就贴这张了）：
上面的图中，每一列就是一个字节，一个字节总共是8位，每一位就是一个二进制数，不同位的值会对应不同的意义。
fin：指示这个是消息的最后片段。第一个片段可能也是最后的片段。如果为1即为最后片段，（其实这个位的用途我个人有点疑惑，按照书上以及网上查的资
料，当数据被分片的时候，不同片应该都会有fin位，会根据fin为是不是0来判断是否为最后一帧，但是实际实现中却发现，当数据比较大需要分片时，服务
端收到的数据就只有第一帧是有fin位为1，其他帧则整个帧都是数据段，也就是说，感觉这个fin位似乎用不上，至少我自己写的demo中是通过数据长度
来判断是否到了最后一帧，完全没用到这个fin位是否为1来判断）
rsv1、rsv2、rsv3：各占一个位，用于扩展协商，基本上不怎么需要理，一般都是0
opcode：占四个位，可以表示0~15的十进制，0表示为附加数据帧，1表示为文本数据帧，2表示二进制数据帧，8表示发送一个连接关闭的数据帧，9
表示ping，10表示pong，ping和pong都是用于心跳检测，当一端发送ping时，另一端必须响应pong表示自己仍处于响应状态。
masked：占一个位，表示是否进行掩码处理，客户端发送给服务端时为1，服务端发送给客户端时为0
payload
length：占7位，或者7+16位、或者7+64位。如果第二个字节的后面七个位的十进制值小于或等于125，则直接用这七个位表示数据长度；如果该
值为126，说明
125<数据长度<65535（16个位能描述的最大值，也就是16个1的时候），就用第三个字节及第四个字节即16个位来表示；如果该值为
127，则说明数据长度已经大于65535，16个位也已经不足以描述数据长度了，就用第三到第十个字节这八个字节来描述数据长度。
masking key：当masked为1的时候才存在，用于对我们需要的数据进行解密。
payload data：我们需要的数据，如果masked为1，该数据会被加密，要通过masking key进行异或运算解密才能获取到真实数据。
帧定义解释完了，就可以根据数据来进行解析了，当有data过来的时候，先获取需要的数据信息，下面这段代码将获取到数据在data里的位置，以及数据长度，masking key以及opcode：
WebSocket.prototype.handleDataStat = function (data) {
if (!this.stat) {
var dataIndex = 2; //数据索引，因为第一个字节和第二个字节肯定不为数据，所以初始值为2
var secondByte = data[1]; //代表masked位和可能是payloadLength位的第二个字节
var hasMask = secondByte >= 128; //如果大于或等于128，说明masked位为1
secondByte -= hasMask ? 128 : 0; //如果有掩码，需要将掩码那一位去掉
var dataLength, maskedData;
//如果为126，则后面16位长的数据为数据长度，如果为127，则后面64位长的数据为数据长度
if (secondByte == 126) {
dataIndex += 2;
dataLength = data.readUInt16BE(2);
} else if (secondByte == 127) {
dataIndex += 8;
dataLength = data.readUInt32BE(2) + data.readUInt32BE(6);
} else {
dataLength = secondByte;
}
//如果有掩码，则获取32位的二进制masking key，同时更新index
if (hasMask) {
maskedData = data.slice(dataIndex, dataIndex + 4);
dataIndex += 4;
}
//数据量最大为10kb
if (dataLength > 10240) {
this.send("Warning : data limit 10kb");
} else {
//计算到此处时，dataIndex为数据位的起始位置，dataLength为数据长度，maskedData为二进制的解密数据
this.stat = {
index: dataIndex,
totalLength: dataLength,
length: dataLength,
maskedData: maskedData,
opcode: parseInt(data[0].toString(16).split("")[1] , 16) //获取第一个字节的opcode位
};
}
} else {
this.stat.index = 0;
}
};
代码中均有注释，理解起来应该不难，直接看下一步，获取到数据信息后，就要对数据进行实际解析了：
经过上面handleDataStat方法的处理，stat中已经有了data的相关数据，先判断opcode，如果为9说明是客户端发起的
ping心跳检测，直接返回pong响应，如果为10则为服务端发起的心跳检测。如果有masking
key，则遍历数据段，对每个字节都与masking
key的字节进行异或运算（网上看到一个说法很形象：就是轮流发生X关系），^符号就是进行异或运算啦。如果没有masking
key则直接通过slice方法把数据截取下来。
获取到数据后，放进datas里保存，因为有可能数据被分片了，所以再将stat里的长度减去当前数据长度，只有当stat里的长度为0的时候，
说明当前帧为最后一帧，然后通过Buffer.concat将所有数据合并，此时再判断一下opcode，如果opcode为8，则说明客户端发起了一个
关闭请求，而我们获取到的数据则是关闭原因。如果不为8，则这数据就是我们需要的数据。然后再将stat重置为null，datas数组置空即可。至此，
我们的数据解析就完成了。
WebSocket.prototype.dataHandle = function (data) {
this.handleDataStat(data);
var stat;
if (!(stat = this.stat)) return;
//如果opcode为9，则发送pong响应，如果opcode为10则置pingtimes为0
if (stat.opcode === 9 || stat.opcode === 10) {
(stat.opcode === 9) ? (this.sendPong()) : (this.pingTimes = 0);
this.reset();
return;
}
var result;
if (stat.maskedData) {
result = new Buffer(data.length-stat.index);
for (var i = stat.index, j = 0; i < data.length; i++, j++) {
//对每个字节进行异或运算，masked是4个字节，所以%4，借此循环
result[j] = data[i] ^ stat.maskedData[j % 4];
}
} else {
result = data.slice(stat.index, data.length);
}
this.datas.push(result);
stat.length -= (data.length - stat.index);
//当长度为0，说明当前帧为最后帧
if (stat.length == 0) {
var buf = Buffer.concat(this.datas, stat.totalLength);
if (stat.opcode == 8) {
this.close(buf.toString());
} else {
this.emit("message", buf.toString());
}
this.reset();
}
};
完成了客户端发来的数据解析，还需要一个服务端发数据至客户端的方法，也就是按照上面所说的帧定义来组装数据并且发送出去。下面的代码中基本上每一行都有注释，应该还是比较容易理解的。
//数据发送
WebSocket.prototype.send = function (message) {
if(this.state !== "OPEN") return;
message = String(message);
var length = Buffer.byteLength(message);
// 数据的起始位置，如果数据长度16位也无法描述，则用64位，即8字节，如果16位能描述则用2字节，否则用第二个字节描述
var index = 2 + (length > 65535 ? 8 : (length > 125 ? 2 : 0));
// 定义buffer，长度为描述字节长度 + message长度
var buffer = new Buffer(index + length);
// 第一个字节，fin位为1，opcode为1
buffer[0] = 129;
// 因为是由服务端发至客户端，所以无需masked掩码
if (length > 65535) {
buffer[1] = 127;
// 长度超过65535的则由8个字节表示，因为4个字节能表达的长度为4294967295，已经完全够用，因此直接将前面4个字节置0
buffer.writeUInt32BE(0, 2);
buffer.writeUInt32BE(length, 6);
} else if (length > 125) {
buffer[1] = 126;
// 长度超过125的话就由2个字节表示
buffer.writeUInt16BE(length, 2);
} else {
buffer[1] = length;
}
// 写入正文
buffer.write(message, index);
this.socket.write(buffer);
};
最后还要实现一个功能，就是心跳检测：防止服务端长时间不与客户端交互而导致客户端关闭连接，所以每隔十秒都会发送一次ping进行心跳检测
//每隔10秒进行一次心跳检测，若连续发出三次心跳却没收到响应则关闭socket
WebSocket.prototype.checkHeartBeat = function () {
var that = this;
setTimeout(function () {
if (that.state !== "OPEN") return;
if (that.pingTimes >= 3) {
that.close("time out");
return;
}
//记录心跳次数
that.pingTimes++;
that.sendPing();
that.checkHeartBeat();
}, 10000);
};
WebSocket.prototype.sendPing = function () {
this.socket.write(new Buffer(['0x89', '0x0']))
};
WebSocket.prototype.sendPong = function () {
this.socket.write(new Buffer(['0x8A', '0x0']))
};
至此，整个websocket的实现就完成了，此demo只是大概实现了一下websocket而已，在安全之类方面肯定还是有很多问题，若是真正生产环境中还是用socket.io这类成熟的插件比较好。不过这还是很值得一学的。
J. 使用Nodejs部署智能合约
实现智能合约的方式很多种，可以用truffle框架来实现，编译，部署。
这里介绍一种简单的使用nodejs来实现，编译，部署的方法。
创建一个nodejs项目，实现一个简单的智能合约。
这个合约实现了一个造币和转币的逻辑。
我们的合约是运行在evm上面的字节码，solidity是静态语言，需要通过编译器生成evm的字节码。
调用 node compile.js ,对BaseToken进行编译，生成字节码。web3中提供了一个部署合约的接口，使用如下，
利用编译生成的abi和bytecode，创建一个合约对象，然后进行发布，等待着异步执行的方法输出合约地址 contractAddress ，这样就完成了部署。不过这种方式有一个问题，就是在发布合约时，你的私钥处于联网状态，
处于安全策略，我们需要尽量避免私钥在联网状态。
以太坊上部署合约是向空地址发送一个附有字节码的签名交易，其中发送者就是这个合约的拥有者。因此我们只需要将合约构建成一笔交易，我们在无网状态下对这笔交易进行签名，然后将签名发送到以太坊网络中。这样能够降低我们私钥被泄漏的风险。
对合约的签名方法如下：
以上对一个合约签名，这里需要注意的问题是，to的地址需要是，空地址。
完成签名之后，我们把这笔交易发送出去就好，最简单的方法就是使用 etherscan的发送Tx的方式 ，一旦发送完成，部署完成，就可以看到合约地址。