澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

2016年8月9日学习笔记,创建一个服务器能根据不

2019-08-24 作者:澳门新萄京赌场网址   |   浏览(182)

小编在读书 NodeJS 文书档案中读出的18个套路

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", "家Love卡的设计费可拉伸的机发送的", 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)

  1. const http = require('http'); 1. 协议
  2. const ip = '192.168.170.129'; 2. IP 地址
  3. const port = 3000; 3. 端口号
  4. http.creatServer{(req.res) =>{ 4. 回掉函数
    res.writeHead(200,{'Conten-Type':'text/html'});
    res.write("<html>");
    res.write("<head>");
    res.write("</head>");
    res.write("<body>");
    res.write('hello');
    res.write("</body>");
    res.end();
  5. }).listen(port,ip,()=>{
  6. cosole.log(server start);

  7. });

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();

  1. const http = require('http'); 1. 协议
  2. const ip = '192.168.170.129'; 2. IP 地址
  3. const port = 3000; 3. 端口号
  4. var f =function (req,res){ res.writeHead(200,{'Conten-Type':'text/html'});
    res.write("<html>");
    res.write("<head>");
    res.write("</head>");
    res.write("<body>");
    res.write('hello');
    res.write("</body>");
    res.end();
    }
    var f2=funcntion (){
    cosole.log(server start);
    }
  5. http.creatServer(f).listen{(port,ip,f2) ;

V8 Inspector

--inspect参数运转你的Node应用程序,它会报告你有个别U大切诺基L。将该UENVISIONL复制到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请求

url (协议 模块)

nextTick 与 setImmediate的区别

这两货的分别可能光从名字上还看不出来,小编觉着应该给它们取个外号:

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

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

* http 是nodejs的服务模块

const fs require('fs');

192.168.84.128:3000/aaaaaa

1. 输出  /aaaaa   
2. 192.168.84.128:3000/aaaaaa/cccc.html   
   输出   /aaaaaa/cccc.html
  1. const http = require('http');
    const http = require('url'); ### url
  2. const ip = '192.168.170.129';
  3. const port = 3000;
    var pathnmae = url.parse(req.url).pathname;
  4. var f =function (req,res){
    var pathnmae = url.parse(req.url).pathname;
    res.write(pathname);
    res.end();
    }
    var f2=funcntion (){
    cosole.log(server start);
    }
  5. http.creatServer(f).listen{(port,ip,f2);

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;

文本的操作

  1. const http = require('http');
    const http = require('url'); ### url
    const fs = require('fs'); ### 文件操作
  2. const ip = '192.168.170.129';
  3. const port = 3000;
    // 1. fs.readFile('a.txt',(err,data)=>{
    // 1. if(err)throw err;
    // 2. console.log(data.toString());
    // 3. });

var data = fs.readFileSync('a.txt');

  1. var f =function (req,res){
    var pathnmae = url.parse(req.url).pathname;
    res.write(pathname);
    res.write('n'); // 或 res.write(pathname 'n');
    res.write(data.toString());
    res.end();
    }
    var f2=funcntion (){
    cosole.log(server start);
    }
  2. http.creatServer(f).listen{(port,ip,f2);

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) =>{

touch 创设文件夹

Logging with colors

别忘了console.dir(obj,{colors:true})可见以差别的情调打印出键与值,那点会大大扩张日志的可读性。

//定义主机IP常量名称

if(err) throw err;

a.tet
  1. aaaaaaaaaaaaaaaaaa
  2. ssssssssssssssssss

touch 创设新文件
cat 读取文件 cat

行使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);

操作方法

    1. chmod 777 a.tet
  1. node a.js

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);

//定义端口号

});

userurl 客商访谈

  1. const http = require('http');
    const http = require('url'); ### url
    const fs = require('fs'); ### 文件操作
    var server=new http.Server();

  2. const ip = '192.168.170.129';

  3. const port = 3000;

  4. server.listen(port,ip);
    server.on('req',function(req,res){
    var pathnmae = url.parse(req.url).pathname;
    var userul = url.parse(pathname);

  5. switch(useurl){
    case '' || '/':
    fs.readFile('./index.html',function(err,content){
    if(err){
    cosole.log(err);
    }

  6. else{

    res.wrireHead(200;{'Conent-Type':'text/html;charset=utf-8'});
    res.write(content);
    res.end();
    }
    }
    break;
    default:
    }});

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){

率先加载全体要求动用的沙盘

    1. var http = require('http')
  1. 加载http服务api模块

  2. var ip = '192.168.84.128';

  3. var fs = require('fs');

  4. 加载fs文件服务api模块

  5. var server = new http.Server();

  6. 创设新的HTTP服务器

  7. var rlapi = require('url');

  8. 创建url路由api模块

  9. server.listen(3000,ip);

  10. 监听端口

  11. // 使用on方法注册事件管理,该事件向来被监听,任何的伸手都会跻身回调函数,实践相应的操作

  12. server.on('request',function(request,response)){

  13. //当有requst需要的时候触1发管理器函数

  14. //解释央浼的url

  15. var url = url.parse(request.url);

  16. //监听乞请的网址,以近日剧本目录为跟目录的url地址

  17. console.log(url.pathname);

  18. //特殊url会让服务器在出殡和埋葬响应前先等待
    switch(url.pathname){

  19. //推断乞请的门路音讯

  20. case '' || '/':

  21. //管理须要的网站更目录,钦定加载对应的公文夹,一帮以根目录,钦赐加载对应的文件夹,一帮以更目录的index.html为暗许,nodejs是高效流管理方案,也能够透过计划文件来配置

  22. fs.readFile("./index.html",function(err,content){

  23. //展开央浼的文书

  24. if(err){

  25. //输出错误音讯,也足以自定义错误新闻

  26. response.writeHead(404,{'Content-Type':'text/plain':charset='utf-8'});

  27. response.withe(err.massage);

  28. response.end();

  29. }else{

  30. //央浼成功重回数据

  31. response.witheHead(200,{'Content-Type':'text/html;charset="uet ='utf-8'"'}); //

  32. response.write(content);

  33. //重回的剧情,有时候还大概会拉长butter数据类型;

  34. response.end();

  35. //甘休响应,不写的话,会间接处于响应状态,页面不会显得内容

     });
    

}
break;
}

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办法也适用于具备的伊夫ntEmitters,希望自身不是终极才清楚那个的:

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查询音信,由此你在采纳UEvoqueL之后要等个几纳秒能力取获得多少。可是事实上您能够应用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.拿走USportageL部分块的内容 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路线来读取不一致的模板文件

2016年8月9日学习笔记,创建一个服务器能根据不同的url地址请求不同的文件模板。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;

}

});

本文由澳门新萄京官方网站发布于澳门新萄京赌场网址,转载请注明出处:2016年8月9日学习笔记,创建一个服务器能根据不

关键词: