Node核心API
1.Buffer对象
<body>
<!--
0.准备知识
0.1计算机只能识别0和1(因为计算机只认识通电和断电两种状态),
0.2所有存储在计算机上的数据都是0和1组成的(数据越大0和1就越多)
0.3计算机中的度量单位
1 B(Byte字节) = 8 bit(位)
// 00000000 就是一个字节
// 111111111 也是一个字节
// 10101010 也是一个字节
// 任意8个 0或1的组合都是一个字节
1 KB = 1024 B
1 MB = 1024KB
1 GB = 1024MB
1.什么是Buffer?
Buffer是NodeJS全局对象上的一个类, 是一个专门用于存储字节数据的类
NodeJS提供了操作计算机底层API, 而计算机底层只能识别0和1,
所以就提供了一个专门用于存储字节数据的类
2.如何创建一个Buffer对象
2.1创建一个指定大小的Buffer
Buffer.alloc(size[, fill[, encoding]])
2.2根据数组/字符串创建一个Buffer对象
Buffer.from(string[, encoding])
3.Buffer对象本质
本质就是一个数组
-->
</body>
js代码
let buf = Buffer.alloc(5);
console.log(buf); // <Buffer 00 00 00 00 00>
// 注意点: 通过console.log();输出Buffer. 会自动将存储的内容转换成16进制再输出
let buf1 = Buffer.alloc(5, 17);
console.log(buf1);
let buf2 = Buffer.from("abc");
console.log(buf2); // <Buffer 61 62 63>
let buf3 = Buffer.from([1, 3, 5]);
console.log(buf3);
// console.dir(buf);
buf[0] = 6;
console.log(buf3);
2.Buffer实例方法
<body>
<!--
1.将二进制数据转换成字符串
返回: <string> 转换后的字符串数据。
buf.toString();
2.往Buffer中写入数据
string <string> 要写入 buf 的字符串。
offset <integer> 开始写入 string 之前要跳过的字节数。默认值: 0。
length <integer> 要写入的字节数。默认值: buf.length - offset。
encoding <string> string 的字符编码。默认值: 'utf8'。
返回: <integer> 已写入的字节数。
buf.write(string[, offset[, length]][, encoding])
3.从指定位置截取新Buffer
start <integer> 新 Buffer 开始的位置。默认值: 0。
end <integer> 新 Buffer 结束的位置（不包含）
buf.slice([start[, end]])
-->
</body>
js代码
let buf = Buffer.from([97, 98, 99]);
console.log(buf); //<Buffer 61 62 63>
console.log(buf.toString());//abc
//以下写入
let buf1 = Buffer.alloc(5); // <Buffer 00 00 00 00 00>
console.log(buf1);
buf1.write("abcdefg", 2, 2);
console.log(buf1); //<Buffer 00 00 61 62 00>
console.log(buf1.toString()); //ab
let buf2 = Buffer.from("abcdefg");
// let buf3 = buf2.slice();
let buf3 = buf2.slice(2); //<Buffer 63 64 65 66 67>
let buf4 = buf2.slice(2,4); //<Buffer 63 64>
console.log(buf3);
console.log(buf3.toString());//cdefg
3.Buffer静态方法
<body>
<!--
1.检查是否支持某种编码格式
Buffer.isEncoding(encoding)
2.检查是否是Buffer类型对象
Buffer.isBuffer(obj)
3.获取Buffer实际字节长度
Buffer.byteLength(string[, encoding])
注意点: 一个汉字占用三个字节
4.合并Buffer中的数据
Buffer.concat(list[, totalLength])
-->
</body>
js代码
// let res = Buffer.isEncoding("gbk");
// console.log(res);
// let obj = {};
// let obj = Buffer.alloc(5);
// let res = Buffer.isBuffer(obj);
// console.log(res);
// let buf = Buffer.from("123");
// let buf = Buffer.from("知播渔"); //9
let res = Buffer.byteLength(buf); //3
console.log(res);//汉字一个顶三个
console.log(buf.length);
let buf1 = Buffer.from("123");
let buf2 = Buffer.from("abc");
let buf3 = Buffer.from("xxx");
let res = Buffer.concat([buf1, buf2, buf3]);
console.log(res);//<Buffer 31 32 33 61 62 63 78 78 78>
console.log(res.toString());//123abcxxx
4.路径模块Path
<body>
<!--
1.路径模块(path)
封装了各种路径相关的操作
和Buffer一样,NodeJS中的路径也是一个特殊的模块
不同的是Buffer模块已经添加到Global上了, 所以不需要手动导入
而Path模块没有添加到Global上, 所以使用时需要手动导入
2.获取路径的最后一部分
path.basename(path[, ext])
let res = path.basename('/a/b/c/d/index.html'); index.html
let res = path.basename('/a/b/c/d'); d
let res = path.basename('/a/b/c/d/index.html', ".html"); index(除去.html)
3.获取路径
path.dirname(path)
let res = path.dirname('/a/b/c/d/index.html');/a/b/c/d
let res = path.dirname('/a/b/c/d');/a/b/c
4.获取扩展名称
path.extname(path)
let res = path.extname('/a/b/c/d/index.html'); .html
let res = path.extname('/a/b/c/d'); 空
console.log(res);
5.判断是否是绝对路径
path.isAbsolute(path)
注意点:
区分操作系统
在Linux操作系统中/开头就是绝对路径
在Windows操作系统中盘符开头就是绝对路径
在Linux操作系统中路径的分隔符是左斜杠 /
在Windows操作系统中路径的分隔符是右斜杠 \
let res = path.isAbsolute('/a/b/c/d/index.html'); // true
let res = path.isAbsolute('./a/b/c/d/index.html'); // false
let res = path.isAbsolute('c:\\a\\b\\c\\d\\index.html'); // true
let res = path.isAbsolute('a\\b\\c\\d\\index.html'); // false
6.获取当前路径环境变量分隔符
path.delimiter （windows是\ Linux是/）
path.delimiter用于获取当前操作系统环境变量的分隔符的
如果是在Linux操作系统中运行那么获取到的是 :
如果是在Windows操作系统中运行那么获取到的是 ;
console.log(path.delimiter);
7.获取当前操作系统路径分隔符
path.sep (windows中使用; linux中使用:)
path.sep用于获取当前操作系统中路径的分隔符的
如果是在Linux操作系统中运行那么获取到的是 左斜杠 /
如果是在Windows操作系统中运行那么获取到的是 右斜杠 \
console.log(path.sep);
1.路径的格式化处理
// path.parse() string->obj
let obj = path.parse("/a/b/c/d/index.html");
console.log(obj);
会转化成以下格式
{
root: '/',
dir: '/a/b/c/d',
base: 'index.html',
ext: '.html',
name: 'index'
};
以下同理
// path.format() obj->string
2.拼接路径
path.join([...paths])
注意点:
如果参数中没有添加/, 那么该方法会自动添加
如果参数中有.., 那么会自动根据前面的参数生成的路径, 去到上一级路径
let str = path.join("/a/b", "c"); // /a/b/c
let str = path.join("/a/b", "/c"); // /a/b/c
let str = path.join("/a/b", "/c", "../"); // /a/b/c -- /a/b
let str = path.join("/a/b", "/c", "../../"); // /a/b/c -- /a
3.规范化路径
path.normalize(path)
let res = path.normalize("/a//b///c////d/////index.html");
console.log(res);
\a\b\c\d\index.html
4.计算相对路径
path.relative(from, to)
let res = path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
console.log(res);
计算完之后是 ..\..\impl\bbb
5.解析路径
path.resolve([...paths])
//如果后面是一个绝对路径，就会忽略前边的
let res = path.resolve('/foo/bar', 'baz'); // /foo/bar/baz
let res = path.resolve('/foo/bar', '../baz'); // /foo/baz
let res = path.resolve('/foo/bar', '/baz'); // /baz
-->
</body>
5.文件操作--fs模块
5.1查看文件状态
<body>
<!--
1.文件模块(fs)
封装了各种文件相关的操作
2.查看文件状态
文件后面有sync的都是同步方法,没有回调函数
fs.stat(path[, options], callback)
fs.statSync(path[, options])
-->
</body>
js代码
fs.stat(__dirname, function (err, stats) {
// console.log("3");
// console.log(err);
// birthtime: 文件的创建时间
// mtime: 文件中内容发生变化, 文件的修改时间
// console.log(stats);
if(stats.isFile()){
console.log("当前路径对应的是一个文件");
}else if(stats.isDirectory()){
console.log("当前路径对应的是一个文件夹");
}
});
let stats = fs.statSync(__filename);
console.log(stats);
//补充 __dirname 为当前文件的上一级目录
//__filename 为当前文件的目录
5.2 文件读取
<!--
1.文件读取
fs.readFile(path[, options], callback)
fs.readFileSync(path[, options])
注意点:
没有指定第二个参数, 默认会将读取到的数据放到Buffer中
第二个参数指定为utf8, 返回的数据就是字符串
-->
js代码
let fs = require("fs");
let path = require("path");
// 1.拿到需要读取的文件路径
let str = path.join(__dirname, "data.txt");
console.log(str);
// 2.读取文件
/*
有回调函数的
fs.readFile(str,"utf8", function (err, data) {
if(err){
throw new Error("读取文件失败");
}
console.log(data);
// console.log(data.toString());
});
*/
let data = fs.readFileSync(str); //<Buffer 77 77 77 2e 69 74 36 36 36 2e 63 6f 6d>
let data = fs.readFileSync(str, "utf8"); //www.it666.com
console.log(data);
5.3 写入文件
<body>
<!--
1.文件写入
fs.writeFile(file, data[, options], callback)
fs.writeFileSync(file, data[, options])
写入的内容既可以是字符串，也可以是buffer
-->
</body>
js代码
let fs = require("fs");
let path = require("path");
// 1.拼接写入的路径
let str = path.join(__dirname, "lnj.txt");
// 2.写入数据
let buf = Buffer.from("www.itzb.com");
fs.writeFile(str, buf, "utf-8", function (err) {
if(err){
throw new Error("写入数据失败");
}else{
console.log("写入数据成功");
}
});
// let res = fs.writeFileSync(str, "知播渔 www.it666.com", "utf-8");
// console.log(res);
5.4 追加写入
<!--
1.追加写入
fs.appendFile(path, data[, options], callback)
fs.appendFileSync(path, data[, options])
-->
let fs = require("fs");
let path = require("path");
// 1.拼接写入的路径
let str = path.join(__dirname, "lnj.txt");
// 2.开始追加数据
fs.appendFile(str, "知播渔", "utf8", function (err) {
if(err){
throw new Error("追加数据失败");
}else{
console.log("追加数据成功");
}
});
5.5 大文件操作
<body>
<!--
1.大文件操作
前面讲解的关于文件写入和读取操作都是一次性将数据读入内存或者一次性写入到文件中
但是如果数据比较大, 直接将所有数据都读到内存中会导致计算机内存爆炸,卡顿,死机等
所以对于比较大的文件我们需要分批读取和写入
fs.createReadStream(path[, options])
fs.createWriteStream(path[, options])
-->
</body>
js代码:首先我们来看一下分批读取
let fs = require("fs");
let path = require("path");
// 1.拼接读取的路径
let str = path.join(__dirname, "lnj.txt");
// 2.创建一个读取流
//highWaterMark用来指定每次读取的大小，单位是字节
let readStream = fs.createReadStream(str, {encoding : "utf8", highWaterMark : 1});
// 3.添加事件监听 读取时有以下几种状态
readStream.on("open", function () {
console.log("表示数据流和文件建立关系成功");
});
readStream.on("error", function () {
console.log("表示数据流和文件建立关系失败");
});
readStream.on("data", function (data) {
console.log("表示通过读取流从文件中读取到了数据", data);
});
readStream.on("close", function () {
console.log("表示数据流断开了和文件的关系, 并且数据已经读取完毕了");
});
在看一下分批写入
// 1.拼接写入的路径
let str = path.join(__dirname, "it666.txt");
// 2.创建一个写入流
let writeStream = fs.createWriteStream(str, {encoding : "utf8"});
// 3.监听写入流的事件
writeStream.on("open", function () {
console.log("表示数据流和文件建立关系成功");
});
writeStream.on("error", function () {
console.log("表示数据流和文件建立关系失败");
});
writeStream.on("close", function () {
console.log("表示数据流断开了和文件的关系");
});
let data = "www.it666.com";
let index = 0;
let timerId = setInterval(function () {
let ch = data[index];
index++;
writeStream.write(ch);
console.log("本次写入了", ch);
if(index === data.length){
clearInterval(timerId);
writeStream.end();
}
}, 1000);
文件拷贝
// 1.生成读取和写入的路径
let readPath = path.join(__dirname, "test.mp4");
let writePath = path.join(__dirname, "abc.mp4");
// 2.创建一个读取流
let readStream = fs.createReadStream(readPath);
// 3.创建一个写入流
let writeStream = fs.createWriteStream(writePath);
// 利用读取流的管道方法来快速的实现文件拷贝
readStream.pipe(writeStream);
5.6 目录操作
<!--
1、创建目录
fs.mkdir(path[, mode], callback)
fs.mkdirSync(path[, mode])
2、读取目录
fs.readdir(path[, options], callback)
fs.readdirSync(path[, options])
3、删除目录
fs.rmdir(path, callback)
fs.rmdirSync(path)
-->
js代码
let fs = require("fs");
let path = require("path");
let str = path.join(__dirname, "abc");
//先创建abc目录
fs.mkdir(str, function (err) {
if(err){
throw new Error("创建目录失败");
}else{
console.log("创建目录成功");
}
});
//在删除abc目录
fs.rmdir(str, function (err) {
if(err){
throw new Error("删除目录失败");
}else{
console.log("删除目录成功");
}
});
//写一个遍历当前文件所在目录所有文件和文件夹
fs.readdir(__dirname, function (err, files) {
if(err){
throw new Error("读取目录失败");
}else{
// console.log(files);
files.forEach(function (obj) {
// console.log(obj);
let filePath = path.join(__dirname, obj);
// console.log(filePath);
let stats = fs.statSync(filePath);
if(stats.isFile()){
console.log("是一个文件", obj);
}else if(stats.isDirectory()){
console.log("是一个目录", obj);
}
});
}
})
利用目录操作来快速创建一个项目模板如下
<body>
<!--
利用NodeJS生成项目模板
projectName
|---images
|---css
|---js
|---index.html
-->
</body>
js代码
let fs = require("fs");
let path = require("path");
class CreateProject {
constructor(rootPath, projectName){
this.rootPath = rootPath;
this.projectName = projectName;
this.subFiles = ["images", "css", "js", "index.html"];
}
initProject(){
// 1.创建站点文件夹
let projectPath = path.join(this.rootPath, this.projectName);
fs.mkdirSync(projectPath);
// 2.创建子文件和子目录
this.subFiles.forEach(function (fileName) {
if(path.extname(fileName) === ""){
let dirPath = path.join(projectPath, fileName);
fs.mkdirSync(dirPath);
}else{
let filePath = path.join(projectPath, fileName);
fs.writeFileSync(filePath, "");
}
})
}
}
let cp = new CreateProject(__dirname, "taobao");
cp.initProject();
6.HTTP模块
6.1 服务器
<body>
<!--
1.什么是HTTP模块
通过Nodejs提供的http模块，我们可以快速的构建一个web服务器,
也就是快速实现过去PHP服务器的功能(接收浏览器请求、响应浏览器请求等)
2.通过HTTP模块实现服务器功能步骤
2.1导入HTTP模块
2.2创建服务器实例对象
2.3绑定请求事件
2.4监听指定端口请求
-->
</body>
js代码
// 1.创建一个服务器实例对象
let server = http.createServer();
// 2.注册请求监听
server.on("request", function (req, res) {
// end方法的作用: 结束本次请求并且返回数据
// res.end("www.it666.com");
// writeHead方法的作用: 告诉浏览器返回的数据是什么类型的, 返回的数据需要用什么字符集来解析
res.writeHead(200, {
"Content-Type": "text/plain; charset=utf-8"
});
res.end("知播渔");
});
// 3.指定监听的端口
server.listen(3000);
//以下为简写
http.createServer(function (req, res) {
res.writeHead(200, {
"Content-Type": "text/plain; charset=utf-8"
});
res.end("知播渔666");
}).listen(3000);
6.2 路径分发
<body>
<!--
1.什么是路径分发?
路径分发也称之为路由, 就是根据不同的请求路径返回不同的数据
2.如何根据不同的请求路径返回不同的数据?
通过请求监听方法中的request对象, 我们可以获取到当前请求的路径
通过判断请求路径的地址就可以实现不同的请求路径返回不同的数据
-->
</body>
js代码
let http = require("http");
// 1.创建一个服务器实例对象
let server = http.createServer();
// 2.注册请求监听
/*
request对象其实是http.IncomingMessage 类的实例,那么就可以使用该类中的方法
其中有个url方法能获取到发出请求的网页路径比如127.0.0.1:3000/index 就会获取到index
response对象其实是http.ServerResponse 类的实例
*/
server.on("request", function (req, res) {
res.writeHead(200, {
"Content-Type": "text/plain; charset=utf-8"
});
// console.log(req.url);
if(req.url.startsWith("/index")){
// 注意点: 如果通过end方法来返回数据, 那么只会返回一次,如果是下面的话,只会返回一句首页1
// res.end("首页1");
// res.end("首页2");
// 注意点: 如果通过write方法来返回数据, 那么可以返回多次
// write方法不具备结束本次请求的功能, 所以还需要手动的调用end方法来结束本次请求
res.write("首页1");
res.write("首页2");
res.end();
}else if(req.url.startsWith("/login")){
res.end("登录");
}else{
res.end("没有数据");
}
});
// 3.指定监听的端口
server.listen(3000);
6.3 响应静态资源(网页,图片,视频等)
<body>
<!--
1.响应静态资源
需要注意的是:在给浏览器返回数据的时候,
如果没有指定响应头的信息,如果没有设置返回数据的类型,
那么浏览器不一定能正确的解析
所以无论返回什么类型的静态资源都需要添加对应的响应头信息
-->
</body>
我们来实现一下
let http = require("http");
let path = require("path");
let ss = require("./15-StaticServer.js");
// 1.创建一个服务器实例对象
let server = http.createServer();
// 2.注册请求监听
server.on("request", function (req, res) {
let rootPath = path.join(__dirname, "www");//此时我们返回的是www目录下的资源,这个根据需求来写
//let rootPath = "C:\\Users\\Jonathan_Lee\\Desktop\\abc";
ss.StaticServer(req, res, rootPath);//在另一个文件封装了一个方法,实现在下面
});
// 3.指定监听的端口
server.listen(3000);
下为15-StaticServer.js文件
let path = require("path");
let fs = require("fs");
let mime = require("./mime.json");
function readFile(req, res, rootPath) {
let filePath = path.join(rootPath, req.url);
/*
注意点:
1.加载其它的资源不能写utf8
2.如果服务器在响应数据的时候没有指定响应头, 那么在有的浏览器上, 响应的数据有可能无法显示
* */
let extName = path.extname(filePath);
let type = mime[extName];//这是通过引入的json文件来判断不同的后缀来指定什么形式
//以下即为该json文件的一些内容
//".323": "text/h323",
//".3gp": "video/3gpp",
if(type.startsWith("text")){
type += "; charset=utf-8;";
}
res.writeHead(200, {
"Content-Type": type
});
fs.readFile(filePath, function (err, content) {
if(err){
res.end("Server Error");
}
res.end(content);
});
}
exports.StaticServer = readFile;
6.4 获取Get,post参数(为返回动态网站做准备)
6.4.1 首先来看获取get参数
<body>
<!--
1.如何拿到Get请求传递过来的参数
使用URL模块
url.format(urlObject) 将路径转换为对象
url.parse(urlString[, parseQueryString[, slashesDenoteHost]]) 将对象转换为路径
-->
</body>
js代码
let url = require("url");
let http = require("http");
/*
let str = "http://root:123456@www.it666.com:80/index.html?name=lnj&age=68#banner";
let obj = url.parse(str, true);
obj里面包括各种信息,query里边是get请求的参数本来字符串,
加上true就会将字符串转化为对象,方便使用
console.log(obj);
console.log(obj.query.name); 这样就能拿到get请求的参数
console.log(obj.query.age);
*/
// 1.创建一个服务器实例对象
let server = http.createServer();
server.on("request", function (req, res) {
// console.log(req.url);
let obj = url.parse(req.url, true);
res.end(obj.query.name + "----" + obj.query.age);
});
// 3.指定监听的端口
server.listen(3000);
6.4.2 获取post参数
<body>
<!--如下我们使用post提交一个表单,提交到//127.0.0.1:81/index.html-->
<form action="http://127.0.0.1:81/index.html" method="post">
<input type="text" name="userName">
<input type="text" name="password">
<input type="submit" value="提交">
</form>
<!--
1.如何拿到POST请求传递过来的参数
使用querystring模块
querystring.parse(str[, sep[, eq[, options]]]) 将参数转换为对象
querystring.stringify(obj[, sep[, eq[, options]]]) 将对象转换为参数
-->
</body>
let http = require("http");
let queryString = require("querystring");
// 1.创建一个服务器实例对象
let server = http.createServer();
server.on("request", function (req, res) {
// 1.定义变量保存传递过来的参数
let params = "";
// 注意点: 在NODEJS中 ,POST请求的参数我们不能一次性拿到, 必须分批获取
req.on("data", function (chunk) {
// 每次只能拿到一部分数据
params += chunk;
});
req.on("end", function () {
// 这里才能拿到完整的数据
// console.log(params);
let obj = queryString.parse(params);
// console.log(obj.userName);
// console.log(obj.password);
res.end(obj.userName + "----" + obj.password);
});
});
// 3.指定监听的端口
server.listen(81);
6.4.3 区分GET-POST请求
<body>
<form action="http://127.0.0.1:3000/index.html" method="get">
<input type="text" name="userName">
<input type="text" name="password">
<input type="submit" value="提交">
</form>
<!--
1.在服务端如何区分用户发送的是GET请求和POST请求?
通过HTTP模块http.IncomingMessage 类的.method属性
-->
js代码
let http = require("http");
// 1.创建一个服务器实例对象
let server = http.createServer();
server.on("request", function (req, res) {
// console.log(req.method);
res.writeHead(200, {
"Content-Type": "text/plain; charset=utf-8"
});
if(req.method.toLowerCase() === "get"){
res.end("利用GET请求的方式处理参数");
}else if(req.method.toLowerCase() === "post"){
res.end("利用POST请求的方式处理参数");
}
});
// 3.指定监听的端口
server.listen(3000);
6.5 返回动态网站
index.html
<body>
<form action="./info.html" method="post">
<input type="text" name="userName">
<input type="submit" value="查询">
</form>
</body>
info.html
<body>
<ul>
<!--<li>姓名: !!!name!!!</li>
<li>性别: !!!gender!!!</li>
<li>年龄: !!!age!!!</li>-->
<li>姓名: <%=name%></li>
<li>性别: <%=gender%></li>
<li>年龄: <%=age%></li>
</ul>
</body>
js模块
let http = require("http");
let path = require("path");
let fs = require("fs");
let url = require("url");
let queryString = require("querystring");
let template = require("art-template");
let persons = {
"lisi": {
name: "lisi",
gender: "male",
age: "33"
},
"zhangsan": {
name: "zhangsan",
gender: "female",
age: "18"
}
};
// 1.创建一个服务器实例对象
let server = http.createServer();
// 2.注册请求监听
server.on("request", function (req, res) {
if(req.url.startsWith("/index") && req.method.toLowerCase() === "get"){
let obj = url.parse(req.url);
let filePath = path.join(__dirname, obj.pathname);
fs.readFile(filePath, "utf8", function (err, content) {
if(err){
res.writeHead(404, {
"Content-Type": "text/plain; charset=utf-8"
});
res.end("Page Not Found");
}
res.writeHead(200, {
"Content-Type": "text/html; charset=utf-8"
});
res.end(content);
});
}
else if(req.url.startsWith("/info") && req.method.toLowerCase() === "post"){
let params = "";
req.on("data", function (chunk) {
params += chunk;
});
req.on("end", function () {
let obj = queryString.parse(params);
let per = persons[obj.userName];
// console.log(per);
let filePath = path.join(__dirname, req.url);
/*
fs.readFile(filePath, "utf8", function (err, content) {
if(err){
res.writeHead(404, {
"Content-Type": "text/plain; charset=utf-8"
});
res.end("Page Not Found");
}
content = content.replace("!!!name!!!", per.name);
content = content.replace("!!!gender!!!", per.gender);
content = content.replace("!!!age!!!", per.age);
res.end(content);
});
*/
// 下为通过模板来修改内容
let html = template(filePath, per);
res.writeHead(200, {
"Content-Type": "text/html; charset=utf-8"
});
res.end(html);
});
}
});
// 3.指定监听的端口
server.listen(3000);
