node.js服务器基础

最新推荐文章于 2025-06-21 11:58:01 发布

原创

最新推荐文章于 2025-06-21 11:58:01 发布 · 1.7k 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#node.js #服务器

node.js的事件循环

node.js是基于事件驱动的，通常在代码中注册想要等待的事件，设定好回调函数，当事件触发的时候就会调用回调函数。如果node.js没有要处理的事件了，那整个就结束了;事件里面可以继续插入事件，如果有事件是一直要继续下去的，那么node 也就不会退出了,每一次事件处理结束后等待下一个事件的发生

console.log("HelloWorld");

// 计时器事件, 每隔一段事件触发一次, time的单位是毫秒
/*setInterval(function  () {
	console.log("get time doing");
}, 5 * 1000); // 每间隔5秒调用一次*/

// 插入一个事件，让它多长时间以后执行一次
setTimeout(function() {
   
   
	console.log("set time out");
}, 3 * 1000);

// process是node的一个全局模块
console.log(process.pid);
console.log(process.version);
console.log(process.platform);
console.log(process.title);
console.log(process.argv); // 在启动的时候，我们可以往程序里面传入参数,参数都是字符串

var argc = process.argv.length;
if (argc >= 3) {
   
   
	console.log(process.argv[2]);
}


console.log(process.execPath); // node所在的路径
console.log(process.env); // 获得系统的环境变量

// 当我们的node在每次退出的时候，都会抛出一个exit这样一个事件，如果我们用户监听这个事件，那么
// 当有exit事件发生的时候，我们之前设置的回掉函数，将会倍调用；
// process.on来监听事件
process.on("exit", function() {
   
   
	console.log("now node exit!!!!");
});

//  当我们发生了一个未知的异常的时候，我们调用这个回掉函数;
// node 停止处理当前这个事件，继续等待下一个事件的处理，不会整个退出，
// 服务器就不会随意的奔溃
// 可以把这个错误，保存起来，方便我们去查找
process.on("uncaughtException", function(err) {
   
   
	console.log("uncaughtException called ", err);
});
// 当我们的程序，如果运行的时候有异常，那么这个时候，我们可以通过捕获异常，
// 如果说我们没有捕获的异常，这个uncaughtException
// 如果发生uncaughtException，node是会退出的;
// 没有主动捕获，所以javascript解释器，他是不会继续执行的;
// current work director 当前的工作目录
// ./ ---> C:\Home\workspace\node_js
// process.chdir("C:\\Home\\workspace"); // 修改我们的工作目录，工作目录默认你的node是在哪个目录下启动的，就是那个目录为你的工作目录
console.log(process.cwd());

// while处理时间，进入等待时间之前调用，完成后，去事件里面来等待新的事件发生；
process.nextTick(function() {
   
   
	console.log("nextTick");
});

TCP网络连接和数据交换

node.js一般用on来监听对应的事件

服务器

// 将net模块 引入进来
var net = require("net");

// 创建一个net.Server用来监听,当连接进来的时候，就会调用我们的函数
// client_sock,就是我们的与客户端通讯建立连接配对的socket
// client_sock 就是与客户端通讯的net.Socket
var server = net.createServer(function(client_sock) {
   
    
	console.log("client comming", client_sock.remoteAddress, client_sock.remotePort);
	// 设置你接受的格式, 
	// client_sock.setEncoding("utf8");
	// client_sock.setEncoding("hex"); // 转成二进制的文本编码
	// 
	// 客户端断开连接的时候处理,用户断线离开了
	client_sock.on("close", function() {
   
   
		console.log("close socket");
	});

	// 接收到客户端的数据，调用这个函数
	// data 默认是Buffer对象，如果你强制设置为utf8,那么底层会先转换成utf8的字符串，传给你
	// hex 底层会把这个Buffer对象转成二进制字符串传给你
	// 如果你没有设置任何编码 <Buffer 48 65 6c 6c 6f 57 6f 72 6c 64 21>
	// utf8 --> HelloWorld!!!   hex--> "48656c6c6f576f726c6421"
	client_sock.on("data", function(data) {
   
   
		console.log(data);

		client_sock.write("goodbye!!!");

		client_sock.end(); // 正常关闭
	});


	client_sock.on("error", function(err) {
   
   
		console.log("error", err);
	});
});

// 当我开始监听的时候就会调用这个回掉函数
server.on("listening", function() {
   
   
	console.log("start listening...");
});


// 监听发生错误的时候调用
server.on("error", function() {
   
   
	console.log("listen error");
});

server.on("close", function() {
   
   
	console.log("server stop listener");
});
/*
server.on("connection", function(client_sock) {
	console.log("client comming 22222");
});
*/
// 编写代码，指示这个server监听到哪个端口上面。
// 127.0.0.1: 6080
// node就会来监听我们的server,等待连接接入
server.listen({
   
   
	port: 6080,
	host: "127.0.0.1",
	exclusive: true,
});

// 停止node对server的监听事件处理，那么node就没有其他的事件要处理，所以就退出了。
// server.unref(); // 取消node,对server的事件的监听；
// server.close(); // 主动的掉这个server.close才会触发这个net.Server的close事件

客户端

var net = require("net");

// net.Socket,
var sock = net.connect({
   
   
	port: 6080,
	host: "127.0.0.1",
}, function() {
   
   
	console.log('connected to server!');
});

// 连接成功调用的事件
sock.on("connect",function() {
   
   
	console.log("connect success");


	// 在这里我们就可以发送数据了
	sock.write("HelloWorld!", "utf8");
	// end 
});
// end

// 有错误发生调用的事件
sock.on("error", function(e) {
   
   
	console.log("error", e);
});

// socket关闭的事件
sock.on("close", function() {
   
   
	console.log("close");
});

// 对方发送了关闭数据包过来的事件
sock.on("end", function() {
   
   
	console.log("end event");
});

// 当有数据发生的时候，调用;
sock.on("data", function(data) {
   
   
	console.log(data);
});

内存管理Buffer模块与大小端

1:4个字节的数据，存到内存的4个字节;
小尾: LE高位的数据 --> 高地址字节地方； --> “高高低低”
大尾: BE高位的数据 --> 低地址字节地方;
2: 通常我们的计算机的CPU，小尾存储;

分配：
Buffer.alloc(); Buffer.allocUnsafe(); Buffer.allocUnsafeSlow
Buffer.from(array); Buffer.from(buf); Buffer.from(string);
获取Buffer的长度 buf.length;

读写：
1: Buffer读取字节 buf[index];
2:根据数据属于大尾小尾来决定使用BE/LE;
3: readFloatBE/readDoubleBE / readFloatLE/readDoubleLE;
4: 读/写整数: read/write
Int8/UInt
Int16BE/Int16LE/UInt16BE/UInt16LE
Int32BE/Int32LE/UInt32BE/UInt32LE
IntBE/IntLE/UIntBE/UIntLE
floatBE/floatLE/doublBE/doubleLE

常用方法：
1:Buffer.byteLength(str, encoding) 返回字符对象对应的二进制长度;
2: 交换swap16, swap32, swap64 大尾小尾数据变化;
3: bu.values(); 遍历buf里面的每个字节;
4: buf转字符串 buf.toString();
5: Buffer转json字符串 JSON.stringify(buf) buf.toJSON;
6: buf.fill，用特定的数据填充buffer

// (1)给定一个大小
// (2)会给这些内存一个初值，如果你没有指定，那么这个初值就是0；
var buf = Buffer.alloc(10, 0xff);
console.log(buf);

// (1) 给定分配一个给定大小的Buffer的内存
// (2) 不会对这些内存区赋初值的,随机的数据，它原来是什么就是什么；
// Unsafe 指的是没有初始化的内存
buf = Buffer.allocUnsafe(10);
console.log(buf);

// 不重Buffer缓冲区里面分配，直接从操作系统分配
// Slow指的是没有重缓冲池里面高效的分配
// Unsafe, 指的是内存，没有被初始化
buf = Buffer.allocUnsafeSlow(10);
console.log(buf);

// 获得我们的bufer对象的长度
// Buffer一旦分配，大小再也不能改变。
console.log(buf.length);

// 方便的创建方式，复制
// 创建一个Buffer对象，用来存放这个字符串的二进制
buf = Buffer.from("Helloworld!");
console.log(buf);


buf = Buffer.from([123, 22, 24, 36, 47, -1]);
console.log(buf);

// 重新创建一个Buffer,然后把原来Buffer的数据拷贝给新的Buffer
var buf2 = Buffer.from(buf);
console.log(buf2);

// buf[index] index [0, len - 1];
console.log(buf[0], buf[1]);

// 以大尾的形式存放 4个字节的整数
// 0x00 00 ff ff --->655535
// 00 00 ff ff
// start从哪里开始
buf.writeInt32BE(65535, 0);
console.log(buf);

// ff ff 00 00
buf.writeInt32LE(65535, 0);
console.log(buf);

// offset是从哪里开始的位置
var value = buf.readInt32LE(0);
console.log(value);


buf.writeFloatLE(3.14, 0);
console.log(buf.readFloatLE(0));


var len = Buffer.byteLength("HelloWorld");
console.log(len);

len = Buffer.byteLength(buf2);
console.log(len);



// 4个字节的Int为例 4 * 4 = 16;
// 0, 1, 2, 3,| 4, 5, 6, 7, |8, 9, 10, 11, |12, 13, 14, 15
buf = Buffer.alloc(4 * 4);
buf.writeInt32LE(65535, 0);
buf.writeInt32LE(65535, 4);
buf.writeInt32LE(65535, 8);
buf.writeInt32LE(65535, 12);
console.log(buf);
buf.swap32();
// 3, 2, 1, 0,| 7, 6, 5, 4, |11, 10, 9, 8, |15, 14, 13, 12
console.log(buf);

console.log(buf.readInt32BE(0))