node(2)

node.js中fs模块系统的使用：

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

1.读取文件：

读取文件：readFile(filename,[options],callback);
filename, 必选参数，文件名
[options],可选参数，可指定flag 默认为‘r’，encoding 默认为null，在读取的时候，需要手动指定
callback 读取文件后的回调函数，参数默认第一个err,第二个data 数据

//文件流模块 fs
//fs node 的内置模块 文件模块 文件读取写入之类的事情
//1.引入文件模块
const fs=require("fs");
module.exports=()=>{
	//readFile 异步读取
    fs.readFile("public/mongodb.txt",(err,data) => {
        if(err){
            throw err;
        }
        let buf=new Buffer(data);
       console.log(data.toString("utf-8"));
    });
    //同步读取方法 readFileSync
    let a=fs.readFileSync("public/mongodb.txt","utf-8");
    console.log(a);
 }

2.打开文件

打开文件：fs.open(filename, flags, [mode], callback);
filename, 必选参数，文件名
flags, 操作标识，如"r",读方式打开，r+可读可写
[mode],设置文件模式(权限)，文件创建默认权限为 0666(可读，可写)。
callback 打开文件后回调函数，参数默认第一个err,第二个fd为一个整数，表示打开文件返回的文件描述符，window中又称文件句柄

//异步打开文件夹
	fs.open("public","r+",(err,id)=>{
   	     if(err){
    	         console.log("打开文件失败")
    	         throw err;
    	     }
         console.log("当前文件已经打开");
     });
     //同步打开文件
    let b=fs.openSync("public","r+")
    console.log(b);

3.获取文件信息

.获取文件信息：fs.stat(path, callback)
path - 文件路径。
callback - 回调函数，带有两个参数如：(err, stats), stats 是 fs.Stats 对象

fs.stat("public",(err,stat)=>{
        if(err){
            throw err;
        }
        //console.log(stat)//输出文件的相关信息
        //stat返回值里面的方法
        //isFile 检测当前文件是文件还是文件夹  true
        //isDirectory 检测当前文件是文件还是文件夹 true
        console.log(stat.isFile());
        console.log(stat.isDirectory());
    });

4.写入文件

创建并写入文件：fs.writeFile(filename,data,[options],callback);
filename, 必选参数，文件名
data, 写入的数据，可以字符或一个Buffer对象
[options],flag 默认‘2’,mode(权限) 默认‘0o666’,encoding 默认‘utf8’
callback 回调函数，回调函数只包含错误信息参数(err)，在写入失败时返回。

 fs.writeFile("public/mode.txt","我想学习","utf-8"，(err)=>{
        if(err){
            throw err;
        }
    });
    //同步写入
    fs.writeFileSync("public/mode.txt","我在学习中","utf-8"");
    //异步方法 appendFile 追加写入
    fs.appendFile("public/mode.txt","我想学习a","utf-8",(err)=>{
        if(err){
            throw err;
        }
    })
    //同步追加appendFileSync

5.文件读取

fs.read(fd, buffer, offset, length, position, callback); 读取文件 ，读取打开的文件内容到缓冲区中
fd, 使用fs.open打开成功后返回的文件描述符
buffer, 一个Buffer对象，v8引擎分配的一段内存
offset, 整数，向缓存区中写入时的初始位置，以字节为单位
length, 整数，读取文件的长度
position, 整数，读取文件初始位置；文件大小以字节为单位
callback(err, bytesRead, buffer), 读取执行完成后回调函数，bytesRead实际读取字节数，被读取的缓存区对象

let buffer=new Buffer(1024);
    fs.open("public/mongodb.txt","r+",(err,fd)=>{
        if(err){
            throw err;
        }
        fs.read(fd,buffer,0,buffer.length,buffer.length,(err,res)=>{
            if(err){
                throw err;
            }
            fs.appendFile("public/mode.txt",buffer.toString("utf-8"),(err)=>{
                if(err){
                    throw err;
                    console.log("写入失败");
                }
                console.log("写入成功")
            })
            console.log(buffer.toString("utf-8"));
        });
    });

6.关闭文件

fs.open("public/mongodb.txt","r+",(err,fd)=>{
        if(err){
            throw err;
        }
        console.log("文件已经打开");
        //文件关闭代码
        fs.close(fd,(error)=>{
            if(error){
                throw error;
            }
            console.log("文件关闭成功")
        });
    });

7.文件的截取

fs.ftruncate(fd, len, callback) 截取文件
fd - 通过 fs.open() 方法返回的文件描述符。
len - 文件内容截取的长度。
callback - 回调函数，没有参数。

let databuff=new Buffer(1024);
    fs.open("public/mongodb.txt","r+",(err,fd)=>{
        if(err){
            throw err;
        }
        //ftruncate 截取文件
        fs.ftruncate(fd,1024,(error)=>{
            if(error){
                throw error;
            }
            console.log("文件截取成功");
            fs.read(fd,databuff,0,databuff.length/2,0,(error,byte)=>{
                if(error){
                    throw error;
                }
                console.log(databuff.toString("utf-8"));
                //文件关闭
                fs.close(fd,(er)=>{
                    if(er){
                        throw er;
                    }
                })
            });
        });
    });
    //fs.ftruncateSync同步截取 

8.删除文件

fs.exists(path, callback); 判断文件或目录是否存在
path, 要查看目录/文件的完整路径及名；
[callback(exists)], 操作完成回调函数；exists true存在，false表示不存在

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

9.创建目录+删除目录

fs.mkdir(path, [mode], callback)创建目录
path是需要创建的目录
[mode]是目录的权限（默认值是0777）
callback 是回调函数。

 let nickname="王五";
    fs.exists(`public/${nickname}`,(exis)=>{
        console.log(exis);
        if(!exis){
            fs.mkdir(`public/${nickname}`,{
                mode:0777
            },(err)=>{
                if(err){
                    throw err;
                }
                console.log("文件创建成功");
                //rmdir 删除目录
                fs.rmdir(`public/${nickname}`,(error)=>{
                     if(error){
                         throw error;
                     }
                     console.log("删除成功");
                 });
            });
        }
        else{
            console.log("该文件存在");
        }
        fs.appendFile(`public/${nickname}`+`/host.txt`,"我在尝试study",(err)=>{
            if(err){
                throw err;
            }
            console.log("写入成功");
        })
    }) 

10.读取目录（fs.readdir(path, callback)）

//递归遍历目录里面的每一层
 let pathinfo="public";
    let method=(path)=>{
    fs.readdir(path,(err,files)=>{
        if(err){
            throw err;
        }
        //[ 'data.txt', 'maodou', 'mark', 'mode.txt', 'mongodb.txt', '王五' ]
        //console.log(files);
        files.map((value,index)=>{
            //console.log(value);
            fs.stat(path+`/${value}`,(error,stats)=>{
                if(error){
                    throw error;
                }
                //开始判断是否是目录还是文件夹
                if(stats.isFile()){
                    console.log(value+"是文件");
                }
                else if(stats.isDirectory()){
                    console.log(value+"是目录");
                    method(path+`/${value}`);
                }
            });
        });
    });
    }
    method(pathinfo);