node模块--http&url&fs&path

前端做后台，轻量级开发，后台接口。例如app小程序

一.配置node环境

① 用node -v和npm -v来检测node环境

② 安装Nodejs开发插件

二.http模块

node之http模块 ，提供流处理api，用来创建服务器

1.了解http

传统的 HTTP 服务器是由 Aphche 、 Nginx 、 IIS 之类的软件来搭建的，但是 Nodejs 并不需要， Nodejs 提供了 http 模块，自身就可以用来构建服务器。http 模块内部封装了高效的 http 服务器 和 http 客户端。

http 模块提供两种使用方式：

1.作为服务端使用时，创建一个 HTTP 服务器，监听 HTTP 客户端请求并返回响应。

2.作为客户端使用时，发起一个 HTTP 客户端请求，获取服务端响应。

require(‘http’)
为了支持各种可能的HTTP应用，Node.js的HTTP API是非常底层的，它只涉及流处理与信息解析。它把一个信息解析成消息头和消息主体

启动服务
node serve.js
配置一个简单服务器
http.createServe().listen()

//写入服务端   需要引入http模块
//1.引入文件
//2.使用api的方法 写所有的服务配置
//3.设置port(端口)   系统端口一般都是3000以下 写程序一般是3000以上   localhost主机名称

const http=require("http");
// req 向服务器发送相关请求，请求相关信息   res 服务器返回的相关信息
http.createServer((req,res)=>{
    //配置响应头的编码格式   汉字的话会出现乱码   200状态码 Status Code
    res.writeHead(200,{"Content-Type":"text/html;charset=utf-8"});
    //相应的数据
    res.write("响应数据");
     //服务结束  有时候打开网址，服务一直在转圈圈
    res.end(); 
}).listen(8100,"localhost",()=>{     //这里只能是localhost，不能写其他的 要写其他的，在c盘里边搜索hosts文件，更改名称即可
    console.log("server start","192.168.90.1:8100"); //可以用192.168.90.1:8100去访问
});

c盘里边的hosts文件,更改其中的localhost即可

三.url模块

也是内置，作用是解析网址路径 eg:www.baidu.com?id=1&name=2 url作用就是取路径后边的值
url.parse() 方法 解析url地址
参数一：解析的路径，参数二：将地址上的值解析出来
req 请求相关数据

const http = require("http");
const url = require("url");

http.createServer((req, res) => {
    if (req.url != "/favicon.ico") {
        let path = url.parse(req.url, true);
        console.log(path.query);
        res.writeHead(200, { "Content-Type": "text/html;charset=utf-8" });
        res.write("解析路径传值："+JSON.stringify(path.query))
        res.end();
    }
}).listen(8100, "localhost", () => {
    console.log("server start", "192.168.90.1:8100");
});

如下图：

var url=require('url');
var src='http://www.baidu.com?name=maodou&sex=0';
//解析地址 
//参数1位解析的路径   参数2：可以将地址上的值解析出来
var path=url.parse(src,true);
console.log(path); 

使用http模块+url模块解析路径上的值

var http=require("http");
var url=require("url");
http.createServer(function (req,res){
    res.writeHead(200,{"Content-Type":"text/html;charset=UTF-8"});

    //解析路径输出路径上的值
    var path=url.parse(req.url,true);
    res.write(path.query.id);
    res.end();
}).listen(8100);

path输出如下图，里边的query，是我们需要的路径上的值

四.更改文件重启服务

在nodejs中文件修改需要重启服务：这要开发比较慢
安装自启动工具supervisor npm install –g supervisor --save
安装完成之后启动文件使用 supervisor 文件名.js 启动服务之后修改代码会自动启动服务

五.Common.js和Node.js模块

抽化为组件，哪里用往哪里调用
exports或者module.exports暴露，需要的模块使用require引入模块。
Commonjs nodejs中的自定义模块
Commonjs规范的提出，弥补javascript没有标准的缺陷，提供一个类似后端语言的标准库，也就是说commonjs是模块化的标准，nodejs就是commonjs模块化的实现。在nodejs中除了http，url，fs等等都是nodejs的内置模块，可以直接使用，commonjs中自定义模块的实现：
在nodejs中将公共的功能抽离为单独的js文件作为模块，在外部是没有办法访问的（类似后端的私有的属性和方法）;要想使用模块，就必须在模块里面通过exports或者module.exports暴露属性或者方法。在需要的模块使用require引入模块。

封装了模块之后，要将整个模块暴露出去
export default http;
module.exports=http;
不断地暴露模块与引入模块

Server.js
var http=require('http');
var ser=http.createServer(function (req,res){
    // 设置http头部  状态  文件类型  字符集
    res.writeHead(200,{"Content-Type":"text/html;charset=UTF-8"});
    //发送响应数据
    res.write("我是node js");
    //设置监听的端口号
    //请求完成之后结束响应
    res.end();
}).listen(8100);
console.log("http://192.168.0.253:8100");

//两种方式导出都可以
// exports.ser=ser;//导出模块
module.exports=ser;

common.js
/*
在js文件里面引入Server.js模块文件
*/
var server=require("./Server.js");//在当前的目录里面找文件 也可以省略.js后缀

todo.js
var stu={
    name:"毛豆",
    setwork:function (){
        return "我在跑nodejs"
    }
}
module.exports=stu;

common2.js
var s=require("./todo");
console.log(s.name);
console.log(s.setwork());


list.js
var stu={
    name:"毛豆",
    setwork:function (){
        return "我在跑nodejs"
    }
}
module.exports=stu;

common3.js
var s=require("./node_Module/list");
console.log(s);

上边写的都是以路径方式引入，建立node_modules文件，可以直接用文件名称引入：
① nodejs 可以自动找node_modules文件下的文件 ：如果node_modules文件下有文件夹 可在cd进入这个文件 使用命令npm init –yes 安装当前文件的package.json文件，直接请求require(“名字”);
② 使用命令 npm init /cnpm init 或者 npm init –yes/cnpm init –yes （这种表示严格模式命名）
命令运行了之后，里边会出现package.json文件，如下图
③ 这种用文件名称进行引入，属于自定义模块封装，自定义模块要写到node_modules文件下

模块化封装

模拟数据库增删改查方法

let connection=(callback)=>{
    //链接数据库 回调函数 数据库操作返回的数据
}
//暴露出去的方法 这个方法又会执行上边connection方法，connection方法里边的回调函数会返回数据

modules.exports.insertData=(result)=>{
    connection(()=>{
        //数据库操作完成之后返回数据
        result(data);
    })
}


//自执行函数封装
module.exports=(()=>{

})();


//es6类封装
class mysql{
    constructor(){
        //类初始化的时候使用
        //public 成员变量（公开访问）
    }
    //下边是成员方法
    insert(){

    }
    update(){

    }
    delete(){

    }
    select(){

    }
}

六.第三方模块

Nodejs的第三方包的使用： 第三方包使用建议官网：www.npmjs.com
单向加密包

比如第三方包： md5-node包 安装包：npm install md5-node –save
安装完之后项目里面生成一个node_modules依赖文件
使用第三方包 var md5=require(‘md5-node’);
console.log(md5(‘123456’)); //e10adc3949ba59abbe56e057f20f883e
这个加密是单向的，只能加密，不能解密

加密解密包

js-base64包 加密解密 npm install --save–dev js-base64
encode加密 decode解密
let base64=require(“js-base64”).Base64;
console.log( base64.encode(“12345”)); //MTIzNDU=

七.fs模块文件系统

1.文件读取
① fs模块 叫做文件系统模块
node的内置模块 文件模块 文件读取写入之类的事情
② fs 中使用的方法 同步异步方法
Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本
例如读取文件内容的函数有异步的 fs.readFile() 和同步的 fs.readFileSync()。
异步的方法函数最后一个参数为回调函数，回调函数的第一个参数包含了错误信息(error)。
建议使用异步方法，比起同步，异步方法性能更高，速度更快，而且没有阻塞

读取文件：
var fs=require("fs");

//异步读取
fs.readFile("content.txt",function (err,data){
    if(err)
    {
        console.log(err);
        throw err;
        //return  false;
    }
    console.log(data.toString("utf-8"));
});

//同步读取
var data=fs.readFileSync("content.txt");
console.log(data.toString("utf-8"));
//或者直接带两个参数
let text=fs.readFileSync("../public/textele.txt","utf-8");
console.log(text);

2.打开文件
fs.open()
r+: 可读可写

//异步打开文件
  fs.open("public","r+",(err,fd)=>{
        if(err){
            console.log("打开文件失败");
            throw err;
        }
        console.log(fd);//4 表示文件打开成功
        console.log("当前文件已经打开");
    })
    
//同步打开文件
    let num=fs.openSync("public","r+");
    console.log(num);//只要输出数字就表示打开成功

3.获取文件信息
判断是否是目录还是文件(是否是文件还是文件夹)
isFile 是文件返回true
isDirectory 是目录返回true

//读取文件信息
fs.stat("content.txt",function (err,stat){
    if(err)
    {
        console.log(err);
        return  false;
    }
    console.log(stats);//输出文件的相关信息
    //stats 返回值里边的方法
    console.log("是否为文件"+stats.isFile());
    console.log("是否为目录"+stats.isDirectory());
});

4.写入文件
文件中写入信息writeFile
参数：文件 写入的文字 回调函数
写入的会进行覆盖，只有当前写入的

    fs.writeFile("content.txt","11111111111111",(err)=>{
        throw err;
    })

追加文件的写入
appendFile追加进去，不进行覆盖

var txt="追加文件的写入";
fs.appendFile("content.txt",txt,function (err){
    if(err)
    {
        console.log(err);
    }
});

5.异步的文件读取
需要使用open方法
Buffer 数据写入的缓冲区
fs.read() 的参数：

fd - 通过 fs.open() 方法返回的文件描述符。
buffer - 数据写入的缓冲区。
offset - 缓冲区写入的写入偏移量。
length - 要从文件中读取的字节数。
position - 文件读取的起始位置，如果 position 的值为null，则会从当前文件指针的位置读取。
callback - 回调函数，有三个参数err, bytesRead, buffer，err为错误信息， bytesRead 表示读取的字节数，buffer 为缓冲区对象。

可以将一个大文件一部分一部分读取，分步读。文件过大读取电脑会崩溃
也可以使用fs.appendFile( )进行边读边写

    let buffer=new Buffer(1024);  //读取1024个字节
    fs.open("../public/textele.txt","r+",(err,fd)=>{
        if(err){
            throw err;
        }
        fs.read(fd,buffer,0,buffer.length,0,(err,res)=>{
            if(err){
                throw err;
            }
            console.log(buffer.toString("utf-8"));
             //边读边写
            fs.appendFile("../public/data.txt",buffer.toString("utf-8"),(err)=>{
                if(err){
                    throw err;
                }
                console.log("写入成功！")
            })
        })
    })

//第二次读取，读取第一次接着后边1024个字节的数据
  fs.read(fd,buffer,0,buffer.length,buffer.length,(err,res)=>{ }

6.关闭文件
fs.close( )

    fs.open("../public/textele","r+",(err,fd)=>{
        if(err){
            throw err;
        }
        //在这里写文件相关代码
        console.log("文件打开成功");
        //文件关闭代码
        fs.close(fd,(error)=>{
           if(error){
               throw error;
           }
            console.log("文件关闭成功");
        })
    })

7.文件的截取
fs.ftruncate()
截取了之后用 fs.read()再读取

 let buffer=new Buffer(1024);
    fs.open("../public/textele","r+",(err,fd)=>{
        if(err){
            throw err;
        }
        fs.ftruncate(fd,1024,(error)=>{
            if(error){
                throw error;
            }
            console.log("文件截取成功");
            fs.read(fd,buffer,0,buffer.length,0,(erro,byte)=>{
                if(erro){
                    throw erro;
                }
                console.log(buffer.toString("utf-8"));   
                console.log(byte);//byte截取出来的字节长度
				     //文件关闭
                fs.close(fd,(er)=>{
                    if(er){
                        throw er;
                    }
                })
            })
        })
    })

8.删除文件
fs.unlink()

    fs.unlink("../public/yextele",(err)=>{
        if(err){
            throw err;
        }
        console.log("文件删除成功");
    })

9.创建目录
fs.exists() 判断文件/目录是否存在
fs.mkdir() 创建目录
fs.rmdir() 删除目录
fs.appendFile() 目录中添加文件，并往文件中写入内容
下边的文件路径拼接采用es6语法

    let name="小明";
    fs.exists(`../public/${name}`,(exis)=>{
        console.log(exis);
        if(!exis){
            fs.mkdir(`../public/${name}`,(err)=>{
                if(err){
                    throw err;
                }
                console.log("文件创建成功");
                fs.rmdir(`../public/${name}`,(error)=>{
                    if(error){
                        throw error;
                    }
                    console.log("文件删除成功");
                })      
            })
        }
        else{
            console.log("文件存在");
        }
        fs.appendFile(`../public/${name}`+`/host.txt`,"创建文件里边写入的东西",(err)=>{
            if(err){
                throw err;
            }
            console.log("写入成功");
        })
    })

10.读取目录
fs.readdir()

    fs.readdir("public",(err,files)=>{
        if(err){
            throw err;
        }
        console.log(files);
    })

将一个目录下的所有文件目录全部输出出来

 let path="public";
    let method=(path)=>{
        fs.readdir(path,(err,files)=>{
            if(err){
                throw err;
            }
            console.log(files);
            files.map((val,ind)=>{
                fs.stat(path+`/${value}`,(error,stats)=>{
                    if(error){
                        console.log(error);
                    }
                    //判断是目录还是文件
                    if(stats.isFile()){
                        console.log(value+"是文件");
                    }
                    else if(stats.isDirectory()){
                        console.log(value+"是目录");
                        //是目录的话继续遍历，遍历到底，递归到目录的每一层
                        method(path+`/${value}`);
                    }
                });
            })
        })
    }
    method();

八.path路径模块

path.extname() 获取文件的后缀名
path.join() 连接路径
__dirname() 拿到当前文件的所有上级目录
path.basename() 返回路径的最后一部分，可以用来取路径最后的文件名

const path=require("path");
module.exports=()=>{
   
    let pathname="maodou.json";
    let hname=path.extname(pathname);
    //找到后缀名后，去后缀名文件里边找到正确的后缀名格式
    console.log(hname);  //.json

    let src=path.join("public","static","shiyu");
    console.log(src);   //public/static/shiyu

    let url=path.resolve("model","mime.json");  /
    console.log(url);
     // 若上边url不写model输出的是：D:\Node\静态web服务器模块\mime.json
     //写了之后输出的是：/D:\Node\静态web服务器模块\model\mime.json 的完整路径
    console.log(__dirname);  //D:\Node\静态web服务器模块\model

    //路径必须是双斜杠
    let name=path.basename("D:\\Node\\静态web服务器模块\\model\\mime.json");
    console.log(name);  //mime.json