Node.js知识点及课堂学习案例

最新推荐文章于 2024-07-22 18:44:51 发布

Bothwo

最新推荐文章于 2024-07-22 18:44:51 发布

阅读量423

点赞数

分类专栏： node.js JavaScript 文章标签： node.js javascript

本文链接：https://blog.csdn.net/weixin_45603113/article/details/120389005

版权

JavaScript 同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

node.js

1 篇文章 0 订阅

订阅专栏

文章目录

- - - 常用API

常用API

1. console

- console.log

var log=console.log;
var user={username:'zhangsan',age:20,sex:'male'}
log('user:%j',user)//{username:'zhangsan',age:20,sex:'male'}
log('username:%s',user.username)
log('age:%d', user.age);
log("sex:%j", user.sex)
log(`${user.username}`);

- console.time

console.time([lable])启动用于计算操作持续时间的计时器。计时器由唯一label标识调用console.timeEnd()时用相同的label停止计时器并将经过的时间以合适的单位输出到stdout

function longTask(){
	for(var i=0;i<1000;i++){
		var n=i*j
	}
}
console.time('test');
longTask()
console.timeEnd('test')
//3ms

2. fir-dir

console.log(__dirname);//获取当前文件执行目录
console.log(__filename);//获取当前包含当前文件的目录

var filePath='';
var platForm=process.platform;//获取当前运行平台 win32 linux等

switch(platForm){
	case'win32':
		filePath=__dirname+"\\index.html";
		break;
	case 'linux':
		filePath=__dirname+'/index.html';
		break;
	default:
		console.log('操作系统平台未知');
		break;
}
console.log(filePath)

//node解决文件路径兼容性的解决方案
//无须根据平台进行判断 直接调用path模块即可
var path=require('path');
var pathStr=path.join(__dirname,'/index.html');
console.log('平台路径为'+pathStr)

3. process

- process对应的方法调用

const log = console.log;

log("操作系统CPU架构:  " + process.arch);
log("操作系统平台:  " + process.platform);
log("属性返回进程的PID:  " + process.pid);
log("启动nod进程的可执行文件的绝对路径:  " + process.execPath);
log("node版本字符串:  " + process.version);
log("node进程当前工作目录:  " + process.cwd());
/* log("用户id:  " + process.geteuid()); */

log("进程在主内存设备中占用的空间量:  " + process.memoryUsage().rss);
log("V8内存使用量版本历史:  " + process.memoryUsage().heapTotal);
log("V8内存使用量版本历史:  " + process.memoryUsage().heapUsed);
log("绑定到 V8 管理的 JavaScript 对象的 C++ 对象的内存使用量:  " + process.memoryUsage().external);

log("包含用户环境的对象:  " + process.env);
log("用户名:  " + process.env.HOSTNAME);

- 命令行参数 process.argv()

var argvArr=process.argv;//argvArr为参数数组
//第一个参数argv[0]：node可执行程序的安装目录 
//第二个参数argv[1]：当前程序所在路径
//第三个参数开始 为命令行传入的参数 
var myorder=argvArr[2]//获取命令行传入的参数值
if(myorder=='hello'){
	console.log('nice to meet you')
}else if(myorder=='test'){
	console.log('I am a test')
}

- 终止进程 process.exit()

终止当前进程并返回给定的code，省略code，退出默认返回成功的状态码 0

var exitCode=process.argv[2]
if(typeof(exitCode)=='undefined')||isNaN(Number(exitCode))){
	console.log('命令行参数不正确')
	process.exit();//退出进程
}else{
	console.log('退出码：'+exitCode);
	process.exit(exitCode)
}

- 标准输入输出流stdin stdout

process.stdin:键盘终端输入
process.stdout:终端显示

//实现命令行提示输入内容 然后进行输入 后综合打入键入内容及结果
var msg = ["userName", "age", "sex"];
var stdin = process.stdin;
var stdout=process.stdout
var index = 0;
var infor = [];
stdout.write(msg[0]+':\n')

stdin.on('data',function (params) {
    var str = params.toString('utf-8');
    infor[index] = str;
    index++;
    if (index == 3) {
        console.log(infor);
        process.exit();
    }
    stdout.write(msg[index]+':\n')
})

var stdin=process.stadin;
//stdin继承了EventEmitter；继承了stream.Readable
stdin.on('data',function(chunk){
	var chunk=chunk.toString('utf-8')//获取键盘键入数据并进行解码
	var result=chunk.slice(0,-2);//将获取数据进行裁取  去掉空格及换行等字符
	if(result==' '){//当键入值为空时 触发结束事件
		stdin.emit('end')		
	}
})
stdin.on('end',function(){
	console.log('stdin ended')
})

- 子进程 process-exec/process-execFile/process-spawn

实现在一个进程中启动另一个进程并且可以接收子进程的标准输出

//exec-child.js
console.log("this message comes from child process")
process.stdout.write("hello node")

//process-exec.js
const { exec } = require("child_process");
const { stdout, stderr } = require("process");

exec('node exec-child.js',(err,stdout,stderr)=>{
	if(err){
		console.log(err)
	}else{
		console.log(stdout)	
	}
})

//linux-exec.js
const { exec } = require("child_process");
const { stderr } = require("process");
//衍生一个shell 执行其指令
exec("cat linux-exec.js", (err,stdout) => {
    if (err) {
        console.log(err)
    } else {
        console.log(stdout)
    }
})

//process-execFile.js
const { execFile } = require("child_process");
//execFile(可执行程序名称/路径，[参数]，回调函数)
//数组中参数形式[执行文件名称，命令行参数]
// 执行node process-execFile.js -test命令即可输出
execFile("node",['exec-child.js','test'], (err,stdout) => {
    if (err) {
        console.log(err)
    } else {
        console.log(stdout)
    }
})

//process-spawn.js
const { spawn } = require("child_process")
//以流的方式进行子进程传输
var showChild=spawn("node", ['exec-child.js'])

showChild.stdout.on('data', (chunk) => {
    console.log(chunk.toString())
})

- 子进程 process-fork

//process-fork.js
const { fork } = require("child_process")
//完成数据通信过程 子进程 父进程相互通信交流 process.send();[发送数据] process.on('message')[接受数据]
var childProcess = fork("fork-child.js")

var index=0
var intervalId = setInterval(() => {
    index++
    childProcess.send("this is message from parent process")
    if (index == 10) {
        clearInterval(intervalId)
    }
},2000)
childProcess.on('message', (chunk) => {
    console.log(chunk)
})

//fork-child.js
process.on("message", (chunk) => {
    console.log(chunk);
})
/* process.send("this is meaasge from child process") */

4. Buffer

- Buffer.from

//编码格式及两种编码形式
var buf=Buffer.from('hhh')
var buf=Buffer.from('hhh','utf-8')
//以上两种编码结果相同 Buffer.from只有一个参数默认为utf-8编码
var buf=Buffer.from('hhh','base64')//将'hhh'字符串按照base64形式进行编码

var buf1=Buffer.from('hello node')
console.log(buf1)//<Buffer 68 65 6c 6c 6f 20 6e 6f 64 65>【按照utf-8编码为此形式】
console.log(buf1.toString())//hello node【按照utf-8形式解码 不写参数默认utf-8形式】
console.log(buf1.length)//包含字符的个数
var buf2=buf1.slice(0,6)
console.log(buf1.toString())

为保证数据保密性前端加密传入数据可能编码与解码形式完全不同

//前端加密传入数据
var userName=process.argv[2];
var pwd=process.argv[3];
var str='userName:'+userName+' pwd'+pwd;
var buf1=Buffer.from(str)//按照utf-8形式进行编码
var str1=buf1.toString('base64');//以base64形式解码

//服务器端解码
var arg=process.argv[2]
var buf1=Buffer.from(arg,'base64');//以base64形式进行编码
var str=buf1.toString();//以utf-8形式进行解码
var arr=str.split(" ");
console.log(buf1)
console.log(str)
console.log(arr)

- eg:向网页添加图片如何能过正常显示图片

var http=require('http')
var fs=require('fs')
var path=require('path');
http.createServer((req,res)=>{
	res.writeHead(200,{'Content-Type':'text/html'});
	var filePath=path.join(__dirname,'./pic.png');
	var imgBuf=fs.readFileSync(filePath)//读取指定文件路径的数据
	var imgBase64=imgBuf.toString('base64')//按照base64形式进行解码
	res.write(`
		<!DOCTYPE html>
                    <head></head>
                    <body style='background:red;'>
                        <img src="https://img-blog.csdnimg.cn/2022010611294860475.png"token template-punctuation string">`+imgBase64+`"/>
                    </body >
                </html > 
`);
res.end()
}).listen(8080)
console.log('服务启动')

5. export

- 对象形式公布

//当前文件名称为：module.js1
var myModule={
	sayHello:function(params){
		console.log('hello modules')
	}
}
function myMethod(){
	console.log('hello inner module');
}

module.exports=myModule;

//接收导出文件
var module1=require('./module1')
mydule1.sayHello();//调用方法打印hello modules
//只有通过module.exports对外公布的方法才可以被外界访问到 所以以下方法调用不可被实现👇
module1.myMethod();

- 函数形式公布

//当前文件名称为：module2.js
function createModule(){
	return{
		sayHello:function(){
			console.log('helllo module2')
		}
	}
}
module.exports=createModule;

//将函数赋值给module.exports 每一次的函数调用过程都会生成一个新的对象，使该对象完成对模块方法的调用
var module2=require('./module2');
var obj=module2();
obj.sayHello();

- 关于第三方包导入 npm install +包名

//已经在控制台执行npm install date-now
var dateNow=require('date-now')
console.log(dateNow())

6. events

EventEmitter 的核心就是事件触发与事件监听器功能的封装。对其进行实例化构造实例化对象

var events=require('events')
var Emitter=events.EventEmitter;//events上的构造方法
var eventObj=new Emitter();
eventObj.on('sayhello',function(){
	console.log('hello world')
})
setTimeout(()=>{//事件触发 定时3s后触发eventObj的sayhello方法
	eventObj.emit('sayhello')
},3000)

eg:

//dog.js
var events=require('events')
var Emitter=events.EventEmitter;
function Dog(dogName){
	Emitter.call(this);//实现对EventEmitter的继承
	this.dogName=dogName;
}
Dog.prototype=Emitter.prototype//实现对EventEmitter的继承
Dog.prototype.bark=function(){
	console.log(this.dogName+":bark")
}
module.exports=Dog//对外公布Dog构造函数

//play-dog.js
var Dog=require('./dog')
var dog=new Dog('wangwang')
dog.on('bark',()=>{
	dog.bark()
})
setTimeout(()=>{
	dog.emit('bark')//emit触发事件 实现每3秒触发bark方法
},3000)

//dog1.js
var events=require('events')
var EventEmitter=events.EventEmitter;

function Dog(name,energy){
	EventEmitter.call(this);
	this.name=name;
	this.energy=energy;
	var intervalId=setInterval(()=>{
		if(this.energy>=0){
			this.emit('bark');
			energy--;	
		}else{
			clearInterval(intervalId)	
		}
	},1000)
}

for(var i in EventEmitter.prototype){
	Dog.prototype[i]=EventEmitter.prototype[i]	
}
module.exports=Dog

//play-dog1.js
var Dog=require('./dog')
var dog=new Dog('taidi',10)

dog.on('bark',()=>{
	console.log(this.name+'barked, energy left'+this.energy)
})

//radio.js
//实现radio对EventEmitter的继承
//start直接触发 stop延迟5秒触发
var events=require('events')
var Emitter=events.EventEmitter;
var util=require('util')
function Radio(infoObj){
	this.radioName=infoObj.radioName
	Emitter.call(this)
}
util.inherits(Radio,Emitter);
module.exports=Radio

//listen-radio.js
var Radio=require('./radio')
var infoObj={radioName:'动物世界'};
var radio=new Radio(infoObj)

//注意以下两种写法：
//- 箭头函数 需要对象名.对象属性
//- 普通函数 this.对象属性 
radio.on('start',()=>{
	console.log(radio.radioName+'started')
})
radio.on('stop',function(){
	console.log(this.radioName+'stoped')
})

setTimeout(()=>{
	radio.emit('start')
},1000)

setTimeout(()=>{
	radio.emit('stop')
},4000)

- util.inherits

util.inherits(constructor,superConstructor)是一个实现对象间原型继承的函数

var util=require('util')
function Base(){
	this.name='base';
	this.base=1991;
	this.sayHello=function(){
		console.log('Hello'+this.name);	
	}
}
Base.prototype.showName=function(){
	console.log(this.name)
}

function Sub(){
	this.name='sub'
}

util.inherits(Sub,Base)

var objBase=new Base()
objBase.showName();//base
objBase.sayHello();//Hello base
console.log(objBase);//{name:base,base:1991,sayHello:[]}//原型中的属性不会作为对象的属性输出

var objSub=new Sub();
objSub.showName();//sub//由util.inherits实现原型继承 所以objSub可以访问到objBase原型上的方法 
//objSub.sayHello();//但是不能访问到objBase自身的方法
console.log(objSub);//{name:sub}

Sub 仅仅继承了Base 在原型中定义的函数，而构造函数内部创造的 base 属性和 sayHello 函数都没有被 Sub 继承。同时在原型中定义的属性不会被console.log 作为对象的属性输出

- 同步异步执行

var timeId=setTimeout(()=>{
	console.log('异步回调函数执行')
},2000)

console.log('同步代码执行1')
console.log('同步代码执行2')
console.log('同步代码执行3')

//输出结果👇
//同步代码执行1
//同步代码执行2
//同步代码执行3
//异步回调函数执行

7. stream

- createReadStream 读文件流

var fs=require('fs')
var path=require('path')

var filePath=path.join(__dirname,'/1.txt')
var readable=fs.createReadStream(filePath)//根据路径创建文件流
readable.on('data',function(chunk){
	console.log(chunk.toString())//根据utf-8形式解码 获取文件中内容
})
//这个参数readable的意义 与参数为 data 监听冲突 只有一个即可
/*readable.on('readable',()=>{	
	console.log('触发该事件表示事件流有了新的动态：新的数据或到了流的尾部')
})*/
readable.on('end',function(chunk){
	console.log('readable end')//读取文件结束时 打印此内容
})

- Readable直接读

var stream=require('require')
var Readable=stream.Readable;

var rs=new Readable()

var c='a'.charCodeAt(0)
rs._read=function(){
	console.log(c)
	if(c<'z'.charCodeAt(0)){
		rs.push(String.fromCharCode(c++))
	}else{
		rs.push(null)	
	}
}
rs.pipe(process.stdout)

- createWriteStream 写文件流

var fs=require('fs')
var path=require('path')

var filePath=join(__dirname,'./2.txt')

var writable=fs.createwrite(filePath);//向指定路径创建写流
writable.write('我是向指定路径写入的内容hhh')
writable.end();

-读写文件流联动

const fs=require('fs')
const path=require('path')

var filePath=path.join(__dirname,'/2.txt')

var readstream=fs.createReadStream(filePath)
var writestream=fs.createWriteStream(path.join(__dirname,'/3.txt'))

readstream.pipe(writestream)

- transform

transform:流数据之间可以进行中间过程转换对原数据处理当有数据流入转换流时对流入六进行加工

const stdin=process.stdin
const stdout=process.stdout

Trans=require('stream').Transform;

stdin.setEncoding('utf-8')
var tf=new Trans()

tf.__transform=function(chunk,encoding,callback){
	this.push(Buffer(chunk.toString('utf-8').toUpper()))
}

- http与读文件流结合

var http=require('http')
var fs=require('fs')
var path=require('path')

http.createServer((req,res)=>{
	var filePath=path.join(__dirname,'./1.txt')
	var readable=fs.createReadStream(filePath)
	readable.pipe(res);//通过管道流向res页面返回值
}).listen(8081)

console.log('Server is listening 8081')

8. fs

- 读文件 readfile&readfilesync

readfile 异步方法
类比setTimeout 延迟执行

const fs=require('fs')
const path=require('path')

var filePath=path.join(__dirname,'/1.txt')
fs.readFile(filePath,(err,data)=>{
	if(err){
		console.log(err)
	}else{
		console.log(data)//Buffer二进制数据
		console.log(data.toString('utf-8'))	
	}
})
console.log('我是同步代码 我将首先执行')

readFilesync 同步方法
同步代码按照顺序依次执行等待文件读取结果后继续向下执行

var fs=require('fs')
var path=require('path')

var filePath=join(__direname,'/1.txt')
var fileContent=fs.readFilesync(filePath)

console.log(fileContent.toString('utf-8'))
console.log('我是同步代码 按顺序我最后执行')

- 写文件 writeFile&writeFilesync

writeFile 异步方法

const fs=require('fs')
const path=require('path')

var filePath=path.join(__dirname,'/2.txt')
fs.writeFile(filePath,'你想写啥就写在这里就行',(err)=>{
	if(err){
		console.log(err)	
	}else{
		console.log('写入成功')	
	}
})

console.log('同步代码执行')

- 指定方式读写文件到指定位置openSync/readSync/alloc

const fs=require('fs')
const path=require('path')

var filePath=join(__dirname,'/2.txt')
//openSync()方法的两个参数 1.读取文件的路径 2.打开文件的方式：只读、只写、可读可写
var fd=fs.openSync(filePath,'r')//可读

var buf=Buffer.alloc(10);//定义一个长度为10的Buffer数据变量 尽可能大的定义 过小可能出现导入数据不完整的现象

fs.readSync(fd,buf)//打开文件 向指定变量内读入
console.log(buf.toString())//实现向指定变量buf内存入读取文件的数据

- 更改文件读写权限 fs.chmodSync(path, mode)

更改指定路径文件的读写权限

const fs=require('fs')
const path=require('path')

var pathFrom=path.join(__dirname,'/1.txt')
var pathTo=path.join(__dirname,'8.txt')

var readStream=createReadStream(pathFrom)
var writeStream=createWriteStream(pathTo)

readStream.pipe(writeStream)

writeStream.on('close',()=>{
	var fileObj=fs.statSync(pathFrom)//获取来源文件相关详细信息
	fs.chmodSync(pathTo,fileObj.mode)
})

- existsSync 查看文件是否存在

const fs=require('fs')
const path=require('path')

var filePath=join(__dirname,'/2.txt')

var Ifexist=fs.existsSync(filePath)
if(Ifexist){
	console.log('该文件存在')
}else{
	console.log('该文件不存在')
}

- fs.access(path[, mode], callback)查看文件权限

测试用户对 path 指定的文件或目录的权限。
在这里插入图片描述

const fs = require('fs')
const path = require('path')
var filePath = path.join(__dirname, '/5.txt')
fs.access(filePath,fs.contants.F_OK,(err)=>{//一般情况下参数为F_OK,即可作为判断文件是否存在的方法
	if(err){
		console.log(err)
	}
})

- fs.readdir 查看指定路径目录情况

const fs = require('fs')
const path = require('path')

var dirPath = __dirname;
fs.readdir(dirPath,(err,files)=>{
	if(err){
		console.log(err)	
	}else{
		console.log(files)	
	}
})

- fs.statSync 查看文件相关属性

const fs = require('fs')
const path = require('path')

function createTime(ctimeMs) {
    var date1 = new Date(ctimeMs)
    console.log(date1.getFullYear()+'/'+date1.getMonth()+'/'+date1.getDate()+' '+date1.getHours()+':'+date1.getMinutes())
}

var
 filePath = path.join(__dirname, '/1.txt')
var fileObj = fs.statSync(filePath)
var ctimeMs = fileObj.ctimeMs
createTime(ctimeMs)

- fs.rename 修改文件名字

将存在的指定文件1.txt更名为10.txt

const fs = require('fs')
const path = require('path')

var oldPath = path.join(__dirname, './1.txt');

var newpath = path.join(__dirname, '/10.txt');

fs.renameSync(oldPath, newpath);

- fs.mkdirSync 创建文件夹

const fs = require('fs')
const path = require('path')

var parentPath = path.join(__dirname, '/folders')
if (!fs.existsSync(parentPath )) {
    fs.mkdirSync(parentPath)
}

- unlinkSync删除文件 rmdirSync删除文件夹

根据文件或文件夹路径递归删除

const fs = require('fs')
const path = require('path')

function delDir(filePath){
	var files=fs.readdirSync(filePath)
	for(var i=0;i<files.length;i++){
		var chilePath=join(__dirname,files[i])
		var obj=fs.statSync(__dirname,childPath[i])
		if(obj.isFile()){
			fs.unlinkSync(childPath)	
		}else{
			delDir(childPath)	
		}	
	}
	fs.rmdirSync(filePath)//删除文件夹
}
var arg=process.argv[2]
var filePath=join(__dirname,'/'+arg)
var fileObj=fs.statSync(filePath)

if(fileObj.isFile()){
	fs.unlinkSync(filePath)
}else{
	delDir(filePath)
}

9. WEB资源管理器

html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <style type="text/css">
        .container {
            background-color: #fff;
            border: 1px solid #e4e4e4;
            border-radius: 5px;
            height: 500px;
            width: 500px;
            border: 3px dotted #eee;
            margin: 0 auto;
            margin-top: 40px;
            padding: 40px;
        }
        ul {
            margin-top: 20px;
        }
        .folder {
            height: 26px;
            width: 26px;
            background: url(./icon.png) -594px -862px no-repeat;
            cursor: pointer;
        }
        .file {
            height: 26px;
            width: 26px;
            background: url(./icon.png)  -594px -68px no-repeat;
            cursor: pointer;
        }
        li {
            list-style: none;
            padding: 0;
            margin: 0;
            display: flex;
            display: -webkit-flex;
            margin-top: 10px;
            border-bottom: 1px solid #f2f6fd;
            padding-bottom: 10px;
        }
        li a, li span {
            text-decoration: none;
            font-size: 12px;
            line-height: 26px;
            color: black;
            margin-left: 20px;
            font-family: "Microsoft YaHei";
        }
        li span {
            /* margin-left: 50px; */
            width: 150px;
            text-align: center;
        }
        li a {
            width: 50px;
            text-align: center;
        }
        li .del {
            margin-right: 0px!important;
        }
        .title {
            display: flex;
            /* display: -webkit-flex; */
            font-size: 12px;
            /* justify-content: space-around; */
            margin-left: 60px;
        }
        
    </style>
</head>
<body>
    <div class="container">
        <div class="title">
            <span>类型</span>
            <span style="margin-left: 40px;">文件名</span>
            <span style="margin-left: 80px;">大小</span>
            <span style="margin-left: 100px;">时间</span>
            <span style="margin-left: 73px;">操作</span>
        </div>
        <ul>
            
        </ul> 
    </div>
</body>
<script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
<script>
    $.get("/getlist", function(data) {
        console.log(data);
        var list = JSON.parse(data)
        for(var i = 0; i < list.length; i++) {
            var liNode = "<li><div class='"+ list[i].fileType +"'></div>" +
                            "<a href='' class='filename' id='file"+ list[i].fileTime +"'>" + list[i].fileName + "</a>" +
                            "<span>" + list[i].fileSize + "</span>" +
                            "<span class='time'>" + list[i].fileTime + "</span>" +
                            "<a href='###' class='del' id='del"+ list[i].fileTime +"' >删除</a></li>";
            $("ul").append(liNode);
        }
    })
    $("ul").on("click",".del",function(e){
        e.preventDefault();
        var delLink = this;
        $.get("/del?delId=" + $(this).attr("id"), function(data) {
            console.log(data);
            if(data.length > 0) {
                $(delLink).parent().remove();
            }
        })
    })
    $("ul").on("click", ".filename", function(e) {
        e.preventDefault();
        var fileNameLink = this;
        $.get("/getfile?fileId=" + $(this).attr("id"), function(data) {
            if($(fileNameLink).prev().attr("class") == "file") {
                document.write(data);
            } 
            else {
                var list = JSON.parse(data);
                $("ul").html("");
                for(var i = 0; i < list.length; i++) {
                    var liNode = "<li><div class='"+ list[i].fileType +"'></div>" +
                                    "<a href='' class='filename' id='file"+ list[i].fileTime +"'>" + list[i].fileName + "</a>" +
                                    "<span>" + list[i].fileSize + "</span>" +
                                    "<span class='time'>" + list[i].fileTime + "</span>" +
                                    "<a href='###' class='del' id='del"+ list[i].fileTime +"' >删除</a></li>";
                    $("ul").append(liNode);
                }
            }
        })
    })
</script>
</html>

JavaScript

const http = require("http");
const fs = require("fs");
const path = require("path");

var pagePath = path.join(__dirname, "/index.html");
var iconPath = path.join(__dirname, "/icon.png");
//转换url，提取数据
function parseUrl(urlStr) {
    var index = urlStr.indexOf("?");
    var pathName = "";
    var args = "";
    var argObj = {};
    if(index == -1) {
        pathName = urlStr;
    }
    else {
        pathName = urlStr.slice(0, index);
        args = urlStr.slice(index + 1);
        var argArr = args.split("&");
        for(var i = 0; i < argArr.length; i++) {
            argObj[argArr[i].split("=")[0]] = argArr[i].split("=")[1];
        }
    }
    return {
        pathName: pathName,
        argObj: argObj
    }
}

function router(urlObj, req, res) {
    if(urlObj.pathName.indexOf(".png") > 0 || urlObj.pathName.indexOf(".jpg") > 0) {
        urlObj.pathName = "getimgdata";
    }
    switch(urlObj.pathName) {
        case "/": 
            showIndex(res);
            break;
        case "getimgdata":
            resImage(res);
            break;
        case "/getlist":
            showList(res);
            break;
        case "/del":
            deleteFile(urlObj.argObj, res);
            break;
    }
}

function showIndex(res) {
    var fileContent = fs.readFileSync(pagePath);
    res.writeHead(200, {"Content-Type": "text/html;charset=utf8"});
    res.write(fileContent);
    res.end();
}

function resImage(res) {
    var imgContent = fs.readFileSync(iconPath);
    res.writeHead(200, {"Content-Type": "image/png"});
    res.write(imgContent);
    res.end();
}

function showList(res) {
    var dirPath = path.join(__dirname, "/fileDir");
    var files = fs.readdirSync(dirPath);
    var fileList = [];
    for(var i = 0; i < files.length; i++) {
        var filePath = path.join(dirPath, "/" + files[i]);
        var fileObj = fs.statSync(filePath);
        var obj = {};
        obj.fileName = files[i];
        obj.fileTime = fileObj.ctimeMs;
        obj.fileSize = fileObj.size;
        obj.fileType = fileObj.isFile() ? "file" : "folder";
        fileList.push(obj);
    }
    var jsonStr = JSON.stringify(fileList);
    res.writeHead(200, {"Content-Type": "text/plain"});
    res.write(jsonStr);
    res.end();
}
function deleteFile(argObj, res) {
    var delId = argObj.delId;
    var dirPath = path.join(__dirname, "/fileDir");
    var files = fs.readdirSync(dirPath);
    for(var i = 0; i < files.length; i++) {
        var fileObj = fs.statSync(path.join(dirPath, "/" + files[i]));
        if(delId.indexOf(fileObj.ctimeMs) > 0) {
            fs.unlinkSync(path.join(dirPath, "/" + files[i]));
            res.end("success");
            break;
        }
    }
}



http.createServer((req, res) => {
    /**
     * http://localhost:8081/pathname?delId=2378382382372645&pageId=10
     * req.url指端口或者域名之后的部分
     */
    var urlStr = req.url;
    var urlObj = parseUrl(urlStr);
    console.log(urlObj);
    router(urlObj, req, res);
}).listen(8081);

console.log("server is listening 8081");