【亚洲必赢官网】创立一个服务器能依据分化的url地址请求例外的文书模板,我在读书

亚洲必赢官网 ,本人在翻阅 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));
【亚洲必赢官网】创立一个服务器能依据分化的url地址请求例外的文书模板,我在读书。}
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(`\r\n`).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(`\r\n`).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;

}

});

网站地图xml地图