1:模块系统
JS这门语言最开始是作为浏览器脚本存在的,本身并没有模块系统,模块的划分靠html中的script标签控制,然而node.js将js作为后台开发语言,必须要有模块划分,如果一个文件要将本文件定义的变量和函数暴露出去,可以使用export:
//文件a.js
let a = 10;
function f(){};
module.exports = {
a:a,
f:f
}
或者
module.exports.a = a;
module.exports.f = f;
如果不涉及函数和数组,直接使用export也可,因此下面这种写法也是可以的
exports.a = a; //a不是数组和函数,可以省略module关键字
module.exports.f = f;
node中模块的实现,本质是将文件包含在了一个函数里,上面文件中的代码编译后会用函数进行包装,转化为下面这种形式,并预先生成module对象,作为参数传入。
module={
id:'a.hs',
exports:{}
}
function load(module){
let a = 10;
function f(){};
return module.exports;
}
如果要使用上面的模块,则需要用到require关键字:
const a = require('./a.js');
console.log(a.a);
a.f();
这是用require导入自定义模块的情况,如果需要使用系统模块,比如文件系统,则不需要添加 ./ 表明在当前目录内:
const fs = require('fs');
在es6之后有了和其他语言一样的import关键字,import是编译时调用,require是运行时调用,因而可以放在文件的任何一个位置(这里其实有个疑惑,import难道不能放在文件的任何一个位置么?)。
2:文件系统
一共分为读、写、文件状态获取、读流、写流、pipe几个部分。
读文件:
const fs = require('fs');
//异步读取
//如果是二进制数据,或者没有指定解析格式为utf-8,则会返回Buffer对象,本质是一个数组,数组中的每个元素是16进制值。
fs.read('文件路径','utf-8',function (err,data) {
if(err){
console.log(err);
}else{
console.log(data);
}
});
//同步读取
try {
let data =fs.readFileSync('文件路径','utf-8');
}catch (e) {
console.log(e)
}
//string和buffer之间相互转化
let data2 = Buffer.from(data,'utf-8'); //将字符串转化为二进制
data = data2.toString('utf-8');
写文件
//同步写入
fs.write('文件路径','utf-8',function (err) {
console.log(err);
});
//异步写入
try {
fs.writeFileSync('文件路径','utf-8');
}catch(e){
console.log(e);
};
readStream
如果文件很大,不可能一次性从磁盘读取到内存中,这个时候就需要使用流的方式每次读一部分。流是一种抽象,就好像从自来水管接一桶水一样。
const rs = fs.createReadStream('文件路径','utf-8');
re.on('data',function (chunk) {}); //读取一段文件
re.on('end',function () {}); //文件读取完毕
re.on('error',function (err) {}); //文件读取出错
writeStream
const ws = fs.createWriteStream('');
ws.write('','utf-8');
ws.write('','utf-8');
ws.end();
pipe
pipe表示管道,如果需要把一个文件的内容读出来,然后写入另一个文件中,就好像在两个文件中建立了一根水管一样,所以叫管道。
过程:使用读流从文件A中读取数据,使用写流将读取的数据写入文件B中
const fs = require('fs');
const rs = fs.createReadStream('文件A','utf-8');
const ws = ts.createWriteStream('文件B');
rs.pipe(ws);
3:http
服务器自然离不开网络,这部分用于接收和响应http请求。
最简单的http服务器:
const http = require('http');
//创建服务器
//这里res对象本质是一个writeStream
const server = http.createServer(function (req,res) {
console.log(req.method);
console.log(req.url);
res.writeHead(200,{
'Content-Type':'text-html'
});
res.end('<h1>hello world</h1>');
});
server.listen(8080);
文件服务器:
const
fs = require('fs');
url =require('url');
path = require('path');
http = require('http');
//||符号:如果左边表达式为真返回左边表达式,否则返回右边表达式,这里如果行命令启动的时候指定了文件路径,那么使用行命令指定的文件路径,否则使用当前代码文件所在的根目录为文件目录 path.resolve('.') 即是获取当前跟目录
const root = path.resolve(process.argv[2] || '.');
const server = http.createServer(function (req,res) {
//获取浏览器中输入的文件路径,这里的路径不包含host和端口因而不需要特殊处理
const pathname = req.url;
const filePath = path.join(root,pathname);
//判断文件是否存在
fs.stat(filePath,function (err,stat) {
if (err){
res.writeHead('404');
res.end('404 not find');
}else{
res.writeHead('200');
const rs = fs.createReadStream(filePath,'utf-8').pipe(res);
}
});
});
server.listen(8080);
console.log('http://127.0.0.1:8080');
4:加密和哈希 —— crypto
hash: 用户验证文件的正确性,同样的文件生成和哈希值是相同的,如果哈希值不同,那么文件肯定也不一样,因而可以用于校验文件的完整性和正确性,hash算法有许多,常用的如MD5、SHA1、SHA256、SHA512等。
MD5:
const crypto = require('crypto');
const md5 = crypto.createHash('md5');
//输入用户MD5加密的内容,这里可以更新多次
md5.update('hello');
md5.update('world');
//使用16进制(hex)输出
console.log(md5.digest('hex'));
Hmac:
Hmac基于MD5、SHA等哈希算法,区别在于Hmac多了一个秘钥,相同的内容如果秘钥不同,生成的哈希也不一样。
const crypto = require('crypto');
//第二个参数即是秘钥
const hmac= crypto.createHmac('md5','goldfish');
hmac.update('hello');
hmac.update('word');
console.log(hmac.digest('hex'));
对称加密aes
let crypto = require('crypto');
function aesEncrypt(data, key, iv) {
//生成加密器,算法为aes192,秘钥为key,初始向量为iv
//只有key和iv都相同,生成的密文才是相同得1
let cipher = crypto.createCipheriv('aes192', key, iv);
//
let crypted = cipher.update(data,'utf-8','hex');
crypted += cipher.final('hex');
return crypted;
}
function aesDecrypt(encrypt, key, iv) {
let decipher = crypto.createDecipheriv('aes192', key, iv);
let decryped = decipher.update(encrypt,'hex','utf-8');
decryped += decipher.final('utf-8');
return decryped;
}
还有一些加密api用到的时候再查
5. web开发 —— KOA2
之前nodejs的web框架为express,但由于express存在callback hell的问题,因此这从KOA2开始学起。
node.js可以使用package.json文件管理包依赖,在js目录下新建该文件,写入如下内容:
{
"name": "hello",
"version": "1.0.0",
"description": "Hello Koa 2 example with async",
"main": "app.js",
"scripts": {
"start": "node app.js"
},
"keywords": [
"koa",
"async"
],
"author": "Tang He",
"license": "Apache-2.0",
"repository": {
"type": "git",
"url": ""
},
"dependencies": {
"koa": "2.0.0"
}
}
然后同样在js目录下输入npm install即可,这种方式在管理多个包的时候更为方便,其实主要就是最后的dependencies。
使用koa2新建一个简单的web服务器:
const koa = require('koa');
const app = new koa();
//async 表示这里使用的是一个异步函数
app.use(async function (ctx, next) {
//调用下一个async函数
await next();
ctx.response.type = 'text/html';
ctx.response.body = '<h1>hello koa</h1>';
});
app.listen(3000);
koa把很多async函数组成一个处理链,每个async函数都可以做一些自己的事情,然后用await next()来调用下一个async函数。我们把每个async函数称为middleware,这些middleware可以组合起来,完成很多有用的功能,看下面的例子。
const koa = require('koa');
const app = new koa();
app.use(async function(context,next) {
console.log(context.request.url+context.request.method);
await next();
});
app.use(async function(context, next) {
const timeBefore = new Date().getTime();
await next();
const timeAfter = new Date().getTime();
console.log(timeAfter-timeBefore);
});
app.use(async function(context, next) {
await next();
context.response.type = 'text/html';
context.response.body = 'hello koa';
});
app.listen(8000);
这里有三个use,先调用第一个use,在该use中调用next()拿到第二个use,同样在第二个use中调用next拿到第三个。如果第二个或者第一个use中的next没有被调用,后面的代码就不会被执行。
koa-router:
提供了路由相关功能,这里路由的实现其实和iOS中的路由框架很像,如果根据用户的请求路径一个个比较效率很低,底层使用哈希表或者二叉查找树就会简单许多,这里koa-router就提供了路由查找的功能。
const koa = require('koa');
const router = require('koa-router')();
const app = new koa();
//接收到请求后打印请求内容,然后转发给下一个use
app.use(async function(context,next) {
console.log(context.request.url+context.request.method);
await next();
});
//将请求转发给路由,路由会选择接收请求的处理函数
app.use(router.routes());
router.get('/',function (context,next) {
context.response.body = '<h1>hello world</h1>'
});
router.get('/goldfish',function (context,next) {
context.response.body = '<h1>hello goldfish</h1>';
});
app.listen(8000);
koa-bodyparser
上面的代码只能用户处理get请求,如果是post请求呢?请求内容在请求体重,无论是node原生还是koa-router都没有提供body解析的功能,这时候就需要一个解析工具 —— koa-bodyparse:
const koa = require('koa');
const bodyParse = require('koa-bodyparser');
const router = require('koa-router')();
const app = new koa();
app.use(async function(context,next) {
console.log(context.request.url+context.request.method);
await next();
});
//请求先被转发到body解析
app.use(bodyParse());
//解析后的请求被转发给路由处理
app.use(router.routes());
router.get('/', async (ctx, next) => {
ctx.response.body = `<h1>Index</h1>
<form action="/login" method="post">
<p>Name: <input name="name" value="koa"></p>
<p>Password: <input name="password" type="password"></p>
<p><input type="submit" value="Submit"></p>
</form>`;
});
router.get('/goldfish',function (context,next) {
context.response.body = '<h1>hello goldfish</h1>';
});
router.post('/login',function (context,next) {
const username = context.request.body.name || '';
const password = context.request.body.password || '';
if (username === 'koa' && password === '123'){
context.response.body = 'success!';
} else {
context.response.body = 'login fail';
}
});
app.listen(8000);
上面的代码,如果响应的请求很多,通常不放在一个文件内,分多个文件写,其中请求处理部分称为controller,单独拉一个文件管理。
MVC
模板引擎部分可以使用 Nunjucks: 官方文档
其中 async 的响应函数就是controller,用于处理业务方面的逻辑,比如判断用户是否存在,从数据库或文件系统中读取数据等。模板就是view,用户视图展示。数据从数据库中取出来,拼接成model,再传递给view。