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

});

复制代码 代码如下:

V8 Inspector

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

var fun = function(){

index.js 复制代码 代码如下: var requestHandler =
require(“./requestHandler”); var server = require(“./server”);…

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

});

function sleep(milliSecond) {
var startTime = new Date().getTime();
console.log(startTime);
while(new Date().getTime() <= milliSecond + startTime) {
}
console.log(new Date().getTime());
}
process.on(‘message’, function() {
sleep(20000);
process.send({});
});

相对地址

你传入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
});

* http 是nodejs的服务模块

测试,当hello还在等待时,upload已经返回。
结语:
大概在最近,我看了博客园上的很多NodeJs文章,大家都认为NodeJS是异步的。但是是何种程度的异步,这个概念就没有几篇文章讲对了。
其实NodeJS,他是一个双层的架构。C++,和javascript。并且是单线程的。这点尤其重要。Node其实是C++利用v8调用js命令,为了实现调用顺序维护了一个Event序列。因此,在一个js
function内部,他的调用绝对会对其他的function产生阻塞。所以,网上所说的process.nextTick和setTimeout等,都不能够产生新的线程,以保证不被阻塞。他所实现的,不过是Event序列的元素顺序问题。
相对于setTimeout,process.nextTick的实现要简单的多,直接加入Event序列的最顶层(有个啥啥事件)。而setTimeout是增加了一个c++线程,在指定的时间将callback加入Event序列
以Node的file
io为例。他的readFile等函数,第二个参数是一个callback。那么node中第一件事就是记录下callback,然后调用底层c++,调用c++开始的过程,你可以看成是异步的。因为那已经到了c++,而不是js这块。所以,exec到callback为止是异步的,http.createServer到触发callback为止是异步的。还有很多,比如mysql的调用方法,不知道大家有没有看过源码,他就是socket发送命令,相信这个过程速度非常快。然后等待回调的过程Node用c++隐藏了,他也是异步的。
而我这篇文章想说明的是,如果再js端有花费大量时间的运算怎么办。就用我上面所说的方法,用js打开c++的线程,这个subprocess.js,不在node的event序列内部维护。是新的线程,因此不会阻塞其他的js
function

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 = 2001;//端口号

首先我们利用NodeJs先构建一个基本的服务器。
index.js

Custom Console

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

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

var requestHandler = require(“./requestHandler”);
var server = require(“./server”);
var route = {
“/hello”: requestHandler.hello,
“/upload”: requestHandler.upload
};
server.start(route);

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

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

var childProcess = require(“child_process”);
exports.hello = function(res) {
var n = childProcess.fork(__dirname + “/subProcess.js”);
n.on(‘message’, function() {
res.writeHead(200, {“Content-Type”: “text/plain”});
res.write(“say hello.”);
res.end();
});
n.send({});
};
exports.upload = function(res) {
res.writeHead(200, {“Content-Type”: “text/plain”});
res.write(“upload”);
res.end();
};

nextTick 与 setImmediate的区别

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

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

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

//监听端口的回掉

在parse中,将head信息解析出来这段是阻塞的。但是真正上传文件却是在req.on(data)中,是利用了事件驱动,是非阻塞的。也就是说,他的非阻塞模型依赖整个nodeJS事件分派架构。
那么像sleep那样消耗大量计算,但是又不能依赖nodeJS分派架构的时候怎么办?
现在介绍一种,类似于html5 WebWorker的方法。
将requestHandler.js改造如下:

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.write(‘my nodejs’);

requestHandler.js

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的文档中。

res.writeHead(200,{‘Content-Type’:’text/html;charset=”utf-8″‘});

复制代码 代码如下:

REPL tricks

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

    1 赞 3 收藏
    评论

图片 2

const http = require(‘http’);

var http = require(“http”);
var url = require(“url”);
exports.start = function(route) {
var server = http.createServer(function(req, res) {
var pathName = url.parse(req.url).pathname;
var handler = route[pathName];
if (handler) {
console.log(“Through path:” + pathName + “:” + new Date().getTime());
handler(res);
} else {
res.writeHead(404, {“Content-Type”: “text/plain”});
res.end();
}
});
server.listen(8088);
};

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`,
// };

res.writeHead(400,{‘Content-Type’:’text/plain;charset=”utf-8″‘});

IncomingForm.prototype.parse = function(req, cb) {
this.pause = function() {
try {
req.pause();
} catch (err) {
// the stream was destroyed
if (!this.ended) {
// before it was completed, crash & burn
this._error(err);
}
return false;
}
return true;
};
this.resume = function() {
try {
req.resume();
} catch (err) {
// the stream was destroyed
if (!this.ended) {
// before it was completed, crash & burn
this._error(err);
}
return false;
}
return true;
};
this.writeHeaders(req.headers);
var self = this;
req
.on(‘error’, function(err) {
self._error(err);
})
.on(‘aborted’, function() {
self.emit(‘aborted’);
})
.on(‘data’, function(buffer) {
self.write(buffer);
})
.on(‘end’, function() {
if (self.error) {
return;
}
var err = self._parser.end();
if (err) {
self._error(err);
}
});
if (cb) {
var fields = {}, files = {};
this
.on(‘field’, function(name, value) {
fields[name] = value;
})
.on(‘file’, function(name, file) {
files[name] = file;
})
.on(‘error’, function(err) {
cb(err, fields, files);
})
.on(‘end’, function() {
cb(null, fields, files);
});
}
return this;
};

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

console.log(‘server start’);

复制代码 代码如下:

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

res.end();

复制代码 代码如下:

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

break;

exports.hello = function(res) {
res.writeHead(200, {“Content-Type”: “text/plain”});
res.write(“say hello.”);
res.end();
};
exports.upload = function(res) {
res.writeHead(200, {“Content-Type”: “text/plain”});
res.write(“upload”);
res.end();
};

HTTP 状态码

NodeJS帮我们内置了HTTP状态码及其描述,也就是http.STATUS_CODES,键为状态值,值为描述:
图片 3

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

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

//console.log(url.pathname);

并加入subProcess.js

避免异常崩溃

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

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中。

res.end();

function sleep(milliSecond) {
var startTime = new Date().getTime();
console.log(startTime);
while(new Date().getTime() <= milliSecond + startTime) {
}
console.log(new Date().getTime());
}
exports.hello = function(res) {
sleep(20000);
res.writeHead(200, {“Content-Type”: “text/plain”});
res.write(“say hello.”);
res.end();
};
exports.upload = function(res) {
res.writeHead(200, {“Content-Type”: “text/plain”});
res.write(“upload”);
res.end();
};

Logging with colors

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

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

在cmd中,键入node index.js即可启动。
但是,上面的代码是阻塞的。如果在createServer的回调函数中,有花费长时间的计算。那么会阻塞node.js的事件轮询。
NodeJS中,他的高效,关键在于快速的返回事件循环。
我们将requestHandler.js改造如下,在这个例子中,由于事件循环一直被sleep函数阻塞着,导致createServer的callback无法及时返回。

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

2016/11/21 · JavaScript
· NodeJS

原文出处: David
Gilbertson   译文出处:王下邀月熊_Chevalier   

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

case ‘/show’:

server.js

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

res.end();

复制代码 代码如下:

//打印字符串内容

复制代码 代码如下:

res.write(parth);

复制代码 代码如下:

//获取请求的url地址

那么先键入
我们试图找寻异步调用的方法。比如formidable中的上传,经测试是非阻塞的。查看formidable的源码,发现最关键的是下面的代码:

case ” || ‘/’:

复制代码 代码如下:

res.end();

server.js

const ip = ‘192.168.1.118’;//主机IP

res.write(error.message);

break;

}

const fs = require(‘fs’);

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

res.write(content);

res.writeHead(400,{‘Content-Type’:’text/plain;charset=”utf-8″‘});

}

res.end();

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

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

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

const fs = require(‘fs’);

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

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

res.write(error.message);

res.write(content);

res.writeHead(400,{‘Content-Type’:’text/plain;charset=”utf-8″‘});

}else{

if(error){

}

const http = require(‘http’);

发表评论

电子邮件地址不会被公开。 必填项已用*标注