金沙棋牌官方平台

当前位置:金沙棋牌 > 金沙棋牌官方平台 > 创建一个服务器能根据不同的url地址请求不同的

创建一个服务器能根据不同的url地址请求不同的

来源:http://www.logblo.com 作者:金沙棋牌 时间:2019-11-08 00:57

我在阅读 NodeJS 文档中读出的19个套路

2016/11/21 · JavaScript · NodeJS

原文出处: David Gilbertson   译文出处:金沙棋牌官方平台,王下邀月熊_Chevalier   

虽然我已经用了三年多的NodeJS,也曾经以为自己对其无所不知。但是我好像从未有安静的坐下来仔细地阅读NodeJS的完整文档。如果有熟悉我的朋友应该知道,我之前已经看了HTML,DOM,Web APIs,CSS,SVG以及ECMAScript的文档,NodeJS是我这个系列的最后一个待翻阅的山峰。在阅读文档的过程中我也发现了很多本来不知道的知识,我觉得我有必要分享给大家。不过文档更多的是平铺直叙,因此我也以阅读的顺序列举出我觉得需要了解的点。

1.小知识点总结

node.js静态页面服务器

1.fs

1>文件操作
一:读取文件

异步读取

fs.readFile("1.txt", "utf-8", function (err, data) {
    if (err) {
        console.error(err);
        return;
    }
    console.log(data);
});

para1:path
para2:encoding
para3:cb(err,data)
无返回值

同步读取

var data = fs.readFileSync("1.txt", "utf-8");
console.log("data: " + data);

para1: path
para2: encoding
有返回值

二:写入文件
>whiteFile

fs.writeFile("2.txt", "哈哈哈哈哈哈哈哈,我会进入文件中", {
flag: "a"
}, function (err) {
if (err) {
console.error(err);
return;
}
console.log("文件写入成功");
});

param1: path
param2: content
param3: options
                        --  flag: a 追加
                   -- flag: w 写入
param4: cb(err)



> appendFile 

fs.appendFile("3.txt", "家乐福卡的设计费可拉伸的机发送的", function (err) {
if (err) {
console.log(err);
return;
}
console.log("文件写入成功");
});

param1: path
param2: content
param3: cb(err)

拓展---复制文件

var fs = require('fs');
fs.readFile("index.html", "utf-8", function (err, data) {
if (err) {
console.error(err);
return;
}
// 写入文件
fs.writeFile("index4.html", data, {
flag: "w",
encoding: "utf-8"
}, function (err) {
if (err) {
console.error(err);
return;
}
console.log("文件赋值成功");
});
});

2>目录操作
 >创建目录

var fs = require('fs');
fs.mkdir("dirName", 0777, function (err) {
if (err) {
console.error(err);
}
});

param1: dirname
param2: 0777
    -权限问题(扩展)
        --mode 三个数字,分别代表owner(所有者),group(组用户),others(其他用户)所具有的权限
        ---1 = x 执行
        ---2 = w 写入
        ---4 = r 读
        ---比如owner所具有的权限: 1 + 2 + 4 = 7
param3: cb(err)


读取目录readdir
>```
var fs = require('fs');
fs.readdir("test", function (err, files) {
    if (err) {
        console.error(err);
        return;
    }
    // files为一个数组,保存所有文件的名称
    console.log(files);
});

param1: dirname
param2: cb(err, cb)

判断文件是否存在exists

var fs = require('fs');
fs.exists("test/test7", function (res) {
console.log(res);
});

param1: dirname
param2: cb(res)

查看目录或者文件详情stat
>```
var fs = require('fs');
fs.stat("test/hah.txt", function (err, stat) {
    if (err) {
        console.error(err);
        return;
    }
    console.log(stat);
});

param1: dirname
param2: cb(err, stat)

修改文件名rename

var fs = require('fs');
fs.rename("test", "testttttttt", function (err) {
if (err) {
console.error(err);
return;
}
console.log("名称修改成功");
});

param1: oldname
param2: newname
param3: cb(err)

相对路径获取绝对路径realpath
>```
var fs = require('fs');
fs.realpath("test", function (err, path) {
    if (err) {
        console.error(err);
        return;
    }
    console.log(path);
});

param1: dirname
param2: cb(err)

querystring:可以用作通用解析器的模块

很多时候我们会从数据库或其他地方得到这种奇怪格式的字符串:name:Sophie;shape:fox;condition:new,一般来说我们会利用字符串切割的方式来讲字符串划分到JavaScript Object。不过querystring也是个不错的现成的工具:

JavaScript

const weirdoString = `name:Sophie;shape:fox;condition:new`; const result = querystring.parse(weirdoString, `;`, `:`); // result: // { // name: `Sophie`, // shape: `fox`, // condition: `new`, // };

1
2
3
4
5
6
7
8
const weirdoString = `name:Sophie;shape:fox;condition:new`;
const result = querystring.parse(weirdoString, `;`, `:`);
// result:
// {
//   name: `Sophie`,
//   shape: `fox`,
//   condition: `new`,
// };

* Xshell 使用open打开一个虚拟机;

const http = require('http');

2 util

1.类型验证

console.log(util.isArray([])); // 验证数组
console.log(util.isRegExp(/d/)); // 验证正则表达式

实现继承
继承原型中的内容,而不继承自身的内容
util.inherits(class, superClass);

// 实现继承
function Person() {
    this.name = "哈哈";
    this.age = 30;
    this.say = function () {
        console.log(this.name);
    };
}
Person.prototype.showAge = function () {
    console.log(this.age);
};
function Student() {
    Person.apply(this, arguments);
    this.name = "呵呵";
}
// 实现继承
util.inherits(Student, Person);
Student.prototype.show = function() {
    console.log("haha");
};
var personObj = new Person();
var studentObj = new Student();
studentObj.say();
studentObj.showAge();
studentObj.show();

V8 Inspector

--inspect参数运行你的Node应用程序,它会反馈你某个URL。将该URL复制到Chrome中并打开,你就可以使用Chrome DevTools来调试你的Node应用程序啦。详细的实验可以参考这篇文章。不过需要注意的是,该参数仍然属于实验性质。
金沙棋牌官方平台 1

* linux 中创建一个空白的日志文件用touch命令;

const url require('url');

3.events

获取事件模块
var events = require('events').EventEmitter(); // 旧的写法
var events = require('events'); // 新的写法
绑定事件
obj.on(“eventName”, function);
obj.addListener(“eventName”, function);
触发事件
obj.emit(“eventName”);
绑定只会触发一次的事件
obj.once(“eventName”, function);

girl.once("die", function () {
    console.log("哈哈哈");
});```

#4.buffer类
缓存区:暂时存放内存里的一段数据

JS自身只有字符串,没有二进制类型在处理文件流时,需要使用二进制数据,因此Node中,定义了一个buffer类

由一个八位字节一个字节元素组成的数组,单位用16进制表示,取值范围为0-255

buffer对象相关方法

1.创建长度为12buff
>// 创建长度为12的数组
var buff = new Buffer(12);
// (填充的值,开始位置,结束位置(没有既全部))
buff.fill(255, 0, 4);
console.log(buff);

2通过数组创建
>var buff = new Buffer([1, 2, 3]);
console.log(buff);

3通过字符串创建
>var buff = new Buffer("李大泽");
console.log(buff);

4将buff转为字符串
>var buff = new Buffer([0xe6, 0x9d, 0x8e, 0xe5, 0xa4, 0xa7, 0xe6, 0xb3, 0xbd]);
console.log(buff.toString());

5.buff连接

var buff1 = new Buffer([0xe6, 0x9d, 0x8e, 0xe5]);
var buff2 = new Buffer([0xa4, 0xa7, 0xe6, 0xb3, 0xbd]);
var buff3 = Buffer.concat([buff1, buff2]); // 连接两个buff,但是会占用过高内存
console.log(buff1.toString());
console.log(buff2.toString());
console.log(buff3.toString());

// Node中推荐的方式

var StringDecoder = require('string_decoder').StringDecoder;
var decoder = new StringDecoder();
console.log(decoder.write(buff1));
console.log(decoder.write(buff2));

#5.stream

---简介

Stream与大数据处理密不可分
之前的文件拷贝,看似没问题,但是对于大文件,会产生内存占用过高问题
var fs = require('fs');
function copy(src, dest) {
fs.writeFile(dest, fs.readFileSync(src));
}
copy("data.json", "dataStream.json");

---解决的问题和方法
内存爆仓
`写入数据跟不上读取速度,写入和读取的速度不一致,未被写入的数据在内存中不断扩大,就会出现内存爆仓`

创建 readStream 和 writeStream,将文件作为一小块一小块的数据流进行处理,而不是一整块技术

var fs = require('fs');
var rs = fs.createReadStream("data.json");
var ws = fs.createWriteStream("data2.json");
rs.on("data", function (chunk) {
console.log("数据读取中。。。。");
ws.write(chunk, function () {
console.log("数据写入成功");
});
});
rs.on("end", function () {
console.log("数据读取完毕");
});

`fs.createReadStream()`
`fs.createWriteStream()`

---pipe

var fs = require('fs');
var rs = fs.createReadStream("data.json");
var ws = fs.createWriteStream("data3.json");
rs.pipe(ws);

    连接两个数据流,犹如导管一样将数据读入写入
    `rs.pipe(ws);`
#6.http
---主要用于搭建HTTP服务器和客户端

---http: 超文本传输协议

---常用api
----创建服务器

var http = require('http');
http.createServer(function (req, res) {
var urlStr = req.url; // 获取请求的路径
var urlMethod = req.method; // 获取请求的方法
console.log(urlStr);
console.log(urlMethod);
res.end();
}).listen(8888, function (err) {
if (err) {
console.error(err);
return;
}
console.log("服务器启动成功");
});
createServer
listen

处理请求

var http = require('http');
var url = require('url');
http.createServer(function (req, res) {
var urlStr = req.url;
var methodStr = req.method;
// console.log(req.headers); // 获取请求头
// console.log(req.httpVersion); // 获取http版本
/*
* 获取GET请求的参数
// 使用url模块对url进行解析
var urlObj = url.parse(urlStr, true);
// 获取get参数
console.log(urlObj.query.name);
*/

// 获取POST请求的参数
req.on("data", function (chunk) {
    console.log(chunk.toString());
});

res.writeHead(200, {"Content-Type": "text/html;charset=utf-8"});
res.end();

}).listen(8888, function (err) {
console.log("服务器启动成功");
});

获取get请求的参数

var urlObj = url.parse(urlStr, true);
console.log(urlObj.query);

获取post请求的参数

req.on("data", function (chunk) {
console.log(chunk.toString());
});

网页中实现请求的发送

var http = require('http');
var url = require('url');
var fs = require('fs');
http.createServer(function (req, res) {
var urlStr = req.url;
var urlObj = url.parse(urlStr, true);
var method = req.method;
var pathname = urlObj.pathname;
if (pathname == "/login.html") {
fs.readFile("login.html", function (err, data) {
res.write(data);
res.end();
});
} else if (pathname == "/test") {
// console.log(urlObj.query);
req.on("data", function (chunk) {
console.log(chunk.toString());
});
res.end();
}
}).listen(8888, "localhost", function (err) {
if (err) {
console.error(err);
return;
}
console.log("服务器启动成功");
});;

get & post请求

nextTick 与 setImmediate的区别

这两货的区别可能光从名字上还看不出来,我觉得应该给它们取个别名:

  • process.nextTick()应该为process.sendThisToTheStartOfTheQueue()
  • setImmediate应该为sendThisToTheEndOfTheQueue()

再说句不相关的,React中的Props应该为stuffThatShouldStayTheSameIfTheUserRefreshes,而State应该为stuffThatShouldBeForgottenIfTheUserRefreshes

* http 是nodejs的服务模块

const fs require('fs');

Server.listen 可以使用Object作为参数

我更喜欢命名参数的方式调用函数,这样相较于仅按照顺序的无命名参数法会更直观。别忘了Server.listen也可以使用某个Object作为参数:

JavaScript

require(`http`) .createServer() .listen({ port: 8080, host: `localhost`, }) .on(`request`, (req, res) => { res.end(`Hello World!`); });

1
2
3
4
5
6
7
8
9
require(`http`)
  .createServer()
  .listen({
    port: 8080,
    host: `localhost`,
  })
  .on(`request`, (req, res) => {
    res.end(`Hello World!`);
  });

不过这个特性不是表述在http.Server这个API中,而是在其父级net.Server的文档中。

* fs 是文件服务器模块

const ip = '192.168.130.2';

相对地址

你传入fs模块的距离可以是相对地址,即相对于process.cwd()。估计有些人早就知道了,不过我之前一直以为是只能使用绝对地址:

JavaScript

const fs = require(`fs`); const path = require(`path`); // why have I always done this... fs.readFile(path.join(__dirname, `myFile.txt`), (err, data) => { // do something }); // when I could just do this? fs.readFile(`./path/to/myFile.txt`, (err, data) => { // do something });

1
2
3
4
5
6
7
8
9
10
const fs = require(`fs`);
const path = require(`path`);
// why have I always done this...
fs.readFile(path.join(__dirname, `myFile.txt`), (err, data) => {
  // do something
});
// when I could just do this?
fs.readFile(`./path/to/myFile.txt`, (err, data) => {
  // do something
});

* url是url路由模块

const port = 3000;

Path Parsing:路径解析

之前我一直不知道的某个功能就是从某个文件名中解析出路径,文件名,文件扩展等等:

JavaScript

myFilePath = `/someDir/someFile.json`; path.parse(myFilePath).base === `someFile.json`; // true path.parse(myFilePath).name === `someFile`; // true path.parse(myFilePath).ext === `.json`; // true

1
2
3
4
myFilePath = `/someDir/someFile.json`;
path.parse(myFilePath).base === `someFile.json`; // true
path.parse(myFilePath).name === `someFile`; // true
path.parse(myFilePath).ext === `.json`; // true

2.创建nodejs服务器;

fs.readFile('/etc/passwd',(err,data) =>{

Logging with colors

别忘了console.dir(obj,{colors:true})能够以不同的色彩打印出键与值,这一点会大大增加日志的可读性。

//定义主机IP常量名称

if(err) throw err;

使用setInterval执行定时任务

我喜欢使用setInterval来定期执行数据库清理任务,不过默认情况下在存在setInterval的时候NodeJS并不会退出,你可以使用如下的方法让Node沉睡:

JavaScript

const dailyCleanup = setInterval(() => { cleanup(); }, 1000 * 60 * 60 * 24); dailyCleanup.unref();

1
2
3
4
const dailyCleanup = setInterval(() => {
  cleanup();
}, 1000 * 60 * 60 * 24);
dailyCleanup.unref();

const ip = '192.168.0.102';

console.log(data);

Use Signal Constants

如果你尝试在NodeJS中杀死某个进程,估计你用过如下语法:

JavaScript

process.kill(process.pid, `SIGTERM`);

1
process.kill(process.pid, `SIGTERM`);

这个没啥问题,不过既然第二个参数同时能够使用字符串与整形变量,那么还不如使用全局变量呢:

JavaScript

process.kill(process.pid, os.constants.signals.SIGTERM);

1
process.kill(process.pid, os.constants.signals.SIGTERM);

//定义端口号

});

IP Address Validation

NodeJS中含有内置的IP地址校验工具,这一点可以免得你写额外的正则表达式:

JavaScript

require(`net`).isIP(`10.0.0.1`) 返回 4 require(`net`).isIP(`cats`) 返回 0

1
2
require(`net`).isIP(`10.0.0.1`) 返回 4
require(`net`).isIP(`cats`) 返回 0

const port = 2000;

var f= function(req,res){

os.EOF

不知道你有没有手写过行结束符,看上去可不漂亮啊。NodeJS内置了os.EOF,其在Windows下是rn,其他地方是n,使用os.EOL能够让你的代码在不同的操作系统上保证一致性:

JavaScript

const fs = require(`fs`); // bad fs.readFile(`./myFile.txt`, `utf8`, (err, data) => { data.split(`rn`).forEach(line => { // do something }); }); // good const os = require(`os`); fs.readFile(`./myFile.txt`, `utf8`, (err, data) => { data.split(os.EOL).forEach(line => { // do something }); });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const fs = require(`fs`);
// bad
fs.readFile(`./myFile.txt`, `utf8`, (err, data) => {
  data.split(`rn`).forEach(line => {
    // do something
  });
});
// good
const os = require(`os`);
fs.readFile(`./myFile.txt`, `utf8`, (err, data) => {
  data.split(os.EOL).forEach(line => {
    // do something
  });
});

//引入的组建模块  http、url、fs

var pathname = url.parse(req.url).pathname;

HTTP 状态码

NodeJS帮我们内置了HTTP状态码及其描述,也就是http.STATUS_CODES,键为状态值,值为描述:
金沙棋牌官方平台 2

你可以按照如下方法使用:

JavaScript

someResponse.code === 301; // true require(`http`).STATUS_CODES[someResponse.code] === `Moved Permanently`; // true

1
2
someResponse.code === 301; // true
require(`http`).STATUS_CODES[someResponse.code] === `Moved Permanently`; // true

const http = require('http');

res.write(pathname);

避免异常崩溃

有时候碰到如下这种导致服务端崩溃的情况还是挺无奈的:

JavaScript

const jsonData = getDataFromSomeApi(); // But oh no, bad data! const data = JSON.parse(jsonData); // Loud crashing noise.

1
2
const jsonData = getDataFromSomeApi(); // But oh no, bad data!
const data = JSON.parse(jsonData); // Loud crashing noise.

我为了避免这种情况,在全局加上了一个:

JavaScript

process.on(`uncaughtException`, console.error);

1
process.on(`uncaughtException`, console.error);

当然,这种办法绝不是最佳实践,如果是在大型项目中我还是会使用PM2,然后将所有可能崩溃的代码加入到try...catch中。

const url = require('url');

res.end();

Just this once()

除了on方法,once方法也适用于所有的EventEmitters,希望我不是最后才知道这个的:

JavaScript

server.once(`request`, (req, res) => res.end(`No more from me.`));

1
server.once(`request`, (req, res) => res.end(`No more from me.`));

const fs = require('fs');

}

Custom Console

你可以使用new console.Console(standardOut,errorOut),然后设置自定义的输出流。你可以选择创建console将数据输出到文件或者Socket或者第三方中。

//创建一个服务

var f2 = function(){

DNS lookup

某个年轻人告诉我,Node并不会缓存DNS查询信息,因此你在使用URL之后要等个几毫秒才能获取到数据。不过其实你可以使用dns.lookup()来缓存数据:

JavaScript

dns.lookup(`www.myApi.com`, 4, (err, address) => { cacheThisForLater(address); });

1
2
3
dns.lookup(`www.myApi.com`, 4, (err, address) => {
  cacheThisForLater(address);
});

var server = http.createServer(function(req,res){

console.log('server start')

fs 在不同OS上有一定差异

  • fs.stats()返回的对象中的mode属性在Windows与其他操作系统中存在差异。
  • fs.lchmod()仅在macOS中有效。
  • 仅在Windows中支持调用fs.symlink()时使用type参数。
  • 仅仅在macOS与Windows中调用fs.watch()时传入recursive选项。
  • 在Linux与Windows中fs.watch()的回调可以传入某个文件名
  • 使用fs.open()以及a+属性打开某个目录时仅仅在FreeBSD以及Windows上起作用,在macOS以及Linux上则存在问题。
  • 在Linux下以追加模式打开某个文件时,传入到fs.write()position参数会被忽略。

res.writeHead(200,{'Content-Type':'text/plain'});

}

net 模块差不多比http快上两倍

笔者在文档中看到一些关于二者性能的讨论,还特地运行了两个服务器来进行真实比较。结果来看http.Server大概每秒可以接入3400个请求,而net.Server可以接入大概5500个请求。

JavaScript

// This makes two connections, one to a tcp server, one to an http server (both in server.js) // It fires off a bunch of connections and times the response // Both send strings. const net = require(`net`); const http = require(`http`); function parseIncomingMessage(res) { return new Promise((resolve) => { let data = ``; res.on(`data`, (chunk) => { data += chunk; }); res.on(`end`, () => resolve(data)); }); } const testLimit = 5000; /* ------------------ */ /* -- NET client -- */ /* ------------------ */ function testNetClient() { const netTest = { startTime: process.hrtime(), responseCount: 0, testCount: 0, payloadData: { type: `millipede`, feet: 100, test: 0, }, }; function handleSocketConnect() { netTest.payloadData.test++; netTest.payloadData.feet++; const payload = JSON.stringify(netTest.payloadData); this.end(payload, `utf8`); } function handleSocketData() { netTest.responseCount++; if (netTest.responseCount === testLimit) { const hrDiff = process.hrtime(netTest.startTime); const elapsedTime = hrDiff[0] * 1e3 + hrDiff[1] / 1e6; const requestsPerSecond = (testLimit / (elapsedTime / 1000)).toLocaleString(); console.info(`net.Server handled an average of ${requestsPerSecond} requests per second.`); } } while (netTest.testCount < testLimit) { netTest.testCount++; const socket = net.connect(8888, handleSocketConnect); socket.on(`data`, handleSocketData); } } /* ------------------- */ /* -- HTTP client -- */ /* ------------------- */ function testHttpClient() { const httpTest = { startTime: process.hrtime(), responseCount: 0, testCount: 0, }; const payloadData = { type: `centipede`, feet: 100, test: 0, }; const options = { hostname: `localhost`, port: 8080, method: `POST`, headers: { 'Content-Type': `application/x-www-form-urlencoded`, }, }; function handleResponse(res) { parseIncomingMessage(res).then(() => { httpTest.responseCount++; if (httpTest.responseCount === testLimit) { const hrDiff = process.hrtime(httpTest.startTime); const elapsedTime = hrDiff[0] * 1e3 + hrDiff[1] / 1e6; const requestsPerSecond = (testLimit / (elapsedTime / 1000)).toLocaleString(); console.info(`http.Server handled an average of ${requestsPerSecond} requests per second.`); } }); } while (httpTest.testCount < testLimit) { httpTest.testCount++; payloadData.test = httpTest.testCount; payloadData.feet++; const payload = JSON.stringify(payloadData); options[`Content-Length`] = Buffer.byteLength(payload); const req = http.request(options, handleResponse); req.end(payload); } } /* -- Start tests -- */ // flip these occasionally to ensure there's no bias based on order setTimeout(() => { console.info(`Starting testNetClient()`); testNetClient(); }, 50); setTimeout(() => { console.info(`Starting testHttpClient()`); testHttpClient(); }, 2000);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
// This makes two connections, one to a tcp server, one to an http server (both in server.js)
// It fires off a bunch of connections and times the response
 
// Both send strings.
 
const net = require(`net`);
const http = require(`http`);
 
function parseIncomingMessage(res) {
  return new Promise((resolve) => {
    let data = ``;
 
    res.on(`data`, (chunk) => {
      data += chunk;
    });
 
    res.on(`end`, () => resolve(data));
  });
}
 
const testLimit = 5000;
 
 
/*  ------------------  */
/*  --  NET client  --  */
/*  ------------------  */
function testNetClient() {
  const netTest = {
    startTime: process.hrtime(),
    responseCount: 0,
    testCount: 0,
    payloadData: {
      type: `millipede`,
      feet: 100,
      test: 0,
    },
  };
 
  function handleSocketConnect() {
    netTest.payloadData.test++;
    netTest.payloadData.feet++;
 
    const payload = JSON.stringify(netTest.payloadData);
 
    this.end(payload, `utf8`);
  }
 
  function handleSocketData() {
    netTest.responseCount++;
 
    if (netTest.responseCount === testLimit) {
      const hrDiff = process.hrtime(netTest.startTime);
      const elapsedTime = hrDiff[0] * 1e3 + hrDiff[1] / 1e6;
      const requestsPerSecond = (testLimit / (elapsedTime / 1000)).toLocaleString();
 
      console.info(`net.Server handled an average of ${requestsPerSecond} requests per second.`);
    }
  }
 
  while (netTest.testCount < testLimit) {
    netTest.testCount++;
    const socket = net.connect(8888, handleSocketConnect);
    socket.on(`data`, handleSocketData);
  }
}
 
 
/*  -------------------  */
/*  --  HTTP client  --  */
/*  -------------------  */
function testHttpClient() {
  const httpTest = {
    startTime: process.hrtime(),
    responseCount: 0,
    testCount: 0,
  };
 
  const payloadData = {
    type: `centipede`,
    feet: 100,
    test: 0,
  };
 
  const options = {
    hostname: `localhost`,
    port: 8080,
    method: `POST`,
    headers: {
      'Content-Type': `application/x-www-form-urlencoded`,
    },
  };
 
  function handleResponse(res) {
    parseIncomingMessage(res).then(() => {
      httpTest.responseCount++;
 
      if (httpTest.responseCount === testLimit) {
        const hrDiff = process.hrtime(httpTest.startTime);
        const elapsedTime = hrDiff[0] * 1e3 + hrDiff[1] / 1e6;
        const requestsPerSecond = (testLimit / (elapsedTime / 1000)).toLocaleString();
 
        console.info(`http.Server handled an average of ${requestsPerSecond} requests per second.`);
      }
    });
  }
 
  while (httpTest.testCount < testLimit) {
    httpTest.testCount++;
    payloadData.test = httpTest.testCount;
    payloadData.feet++;
 
    const payload = JSON.stringify(payloadData);
 
    options[`Content-Length`] = Buffer.byteLength(payload);
 
    const req = http.request(options, handleResponse);
    req.end(payload);
  }
}
 
/*  --  Start tests  --  */
// flip these occasionally to ensure there's no bias based on order
setTimeout(() => {
  console.info(`Starting testNetClient()`);
  testNetClient();
}, 50);
 
setTimeout(() => {
  console.info(`Starting testHttpClient()`);
  testHttpClient();
}, 2000);

JavaScript

// This sets up two servers. A TCP and an HTTP one. // For each response, it parses the received string as JSON, converts that object and returns a string const net = require(`net`); const http = require(`http`); function renderAnimalString(jsonString) { const data = JSON.parse(jsonString); return `${data.test}: your are a ${data.type} and you have ${data.feet} feet.`; } /* ------------------ */ /* -- NET server -- */ /* ------------------ */ net .createServer((socket) => { socket.on(`data`, (jsonString) => { socket.end(renderAnimalString(jsonString)); }); }) .listen(8888); /* ------------------- */ /* -- HTTP server -- */ /* ------------------- */ function parseIncomingMessage(res) { return new Promise((resolve) => { let data = ``; res.on(`data`, (chunk) => { data += chunk; }); res.on(`end`, () => resolve(data)); }); } http .createServer() .listen(8080) .on(`request`, (req, res) => { parseIncomingMessage(req).then((jsonString) => { res.end(renderAnimalString(jsonString)); }); });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// This sets up two servers. A TCP and an HTTP one.
// For each response, it parses the received string as JSON, converts that object and returns a string
const net = require(`net`);
const http = require(`http`);
 
function renderAnimalString(jsonString) {
  const data = JSON.parse(jsonString);
  return `${data.test}: your are a ${data.type} and you have ${data.feet} feet.`;
}
 
 
/*  ------------------  */
/*  --  NET server  --  */
/*  ------------------  */
 
net
  .createServer((socket) => {
    socket.on(`data`, (jsonString) => {
      socket.end(renderAnimalString(jsonString));
    });
  })
  .listen(8888);
 
 
/*  -------------------  */
/*  --  HTTP server  --  */
/*  -------------------  */
 
function parseIncomingMessage(res) {
  return new Promise((resolve) => {
    let data = ``;
 
    res.on(`data`, (chunk) => {
      data += chunk;
    });
 
    res.on(`end`, () => resolve(data));
  });
}
 
http
  .createServer()
  .listen(8080)
  .on(`request`, (req, res) => {
    parseIncomingMessage(req).then((jsonString) => {
      res.end(renderAnimalString(jsonString));
    });
  });

res.write('my nodejs');

REPL tricks

  • 如果你是在REPL模式下,就是直接输入node然后进入交互状态的模式。你可以直接输入.load someFile.js然后可以载入包含自定义常量的文件。
  • 可以通过设置NODE_REPL_HISTORY=""来避免将日志写入到文件中。
  • _用来记录最后一个计算值。
  • 在REPL启动之后,所有的模块都已经直接加载成功。可以使用os.arch()而不是require(os).arch()来使用。

    1 赞 3 收藏 评论

金沙棋牌官方平台 3

res.end();

});

//监听一个端口

server.listen(port,ip,function(){

console.log('server start');

});

3.获取URL部分块的内容 url;

const ip = '192.168.1.118';//主机IP

const port = 2001;//端口号

//引入的组建模块  http、url、fs

const http = require('http');

const url = require('url');

const fs = require('fs');

//创建服务的回掉函数

var funSer = function(req,res){

//获取url地址块的内容  如:/path/show

var parth = url.parse(req.url).pathname;

res.write(parth);

res.end();

}

//监听端口的回掉

var fun = function(){

console.log('server start');

}

var server = http.createServer(funSer).listen(port,ip,fun);

4.读取文件的内容 File System;

const ip = '192.168.1.118';//主机IP

const port = 2001;//端口号

//引入的组建模块  http、url、fs

const http = require('http');

const url = require('url');

const fs = require('fs');

//真正打印文件内容

fs.readFile('./index.html', (err, data) => {

if (err) throw err;

//打印字符串内容

console.log(data.toString());

});

//创建服务的回掉函数

var funSer = function(req,res){

//获取url地址块的内容  如:/path/show

var parth = url.parse(req.url).pathname;

res.write(parth);

res.end();

}

//监听端口的回掉

var fun = function(){

console.log('server start');

}

var server = http.createServer(funSer).listen(port,ip,fun);

  1. 完整实例(根据不同的url地址请求不同的文件【模板】)

const ip = '192.168.1.118';//主机IP

const port = 2001;//端口号

//引入的组建模块  http、url、fs

const http = require('http');

const url = require('url');

const fs = require('fs');

//实例化一个服务容器

var server = new http.Server();

//监听一个端口

server.listen(port , ip);

//注册一个事件处理的on方法

server.on('request' , function(req , res){

//获取请求的url地址

var url = urls.parse(req.url);

//console.log(url.pathname);

//根据path路径来读取不同的模板文件

switch( url.pathname ){

case '' || '/':

//读取文件内容

fs.readFile('./index.html',function( error, content){

if(error){//如果有错误时,显示错误信息

res.writeHead(400,{'Content-Type':'text/plain;charset="utf-8"'});

res.write(error.message);

res.end();

}else{

//正确时浏览器输出模板文件的内容

res.writeHead(200,{'Content-Type':'text/html;charset="utf-8"'});//头信息

res.write(content);//模板文件内容

res.end();

}

});

break;

case '/list':

fs.readFile('./list.html',function( error, content){

if(error){

res.writeHead(400,{'Content-Type':'text/plain;charset="utf-8"'});

res.write(error.message);

res.end();

}else{

res.writeHead(200,{'Content-Type':'text/html;charset="utf-8"'});

res.write(content);

res.end();

}

});

break;

case '/show':

fs.readFile('./show.html',function( error, content){

if(error){

res.writeHead(400,{'Content-Type':'text/plain;charset="utf-8"'});

res.write(error.message);

res.end();

}else{

res.writeHead(200,{'Content-Type':'text/html;charset="utf-8"'});

res.write(content);

res.end();

}

});

break;

default:

fs.readFile('./default.html',function( error, content){

if(error){

res.writeHead(400,{'Content-Type':'text/plain;charset="utf-8"'});

res.write(error.message);

res.end();

}else{

res.writeHead(200,{'Content-Type':'text/html;charset="utf-8"'});

res.write(content);

res.end();

}

});

break;

}

});

本文由金沙棋牌发布于金沙棋牌官方平台,转载请注明出处:创建一个服务器能根据不同的url地址请求不同的

关键词:

上一篇:没有了

下一篇:没有了