node-fs

fs

文章目录

  • fs
      • fs基础方法:(同步 异步之分)
      • fs掌握知识点
          • 1、根据文件大小 读取文件(水龙头开关 流 块)
          • 2、根据文件大小 拷贝文件(管道流 块)
          • 3、利用递归-拷贝文件夹
          • 4、利用递归-删除文件夹
          • 5、利用递归-读取文件夹的内容 生成json文件
          • 6、利用递归-读取json数据 生成文件夹目录
          • 7、利用递归-创建文件夹
          • 8、文件的合并

fs基础方法:(同步 异步之分)

  • 文件:读 写 拷贝 追加
  • 文件夹/目录:读取 遍历 路径拼接
  • 判断文件/目录是否存在
  • 查看文件信息 ( 大小?是文件? 是文件夹?)

fs掌握知识点

1、根据文件大小 读取文件(水龙头开关 流 块)
/**@筱淑
 * 文件的读取
 */
const {readFile,existsSync,statSync,createReadStream} = require("fs");
const path = require("path");
let initSize = 20*1024;
class ReadFile{
    constructor(src){
        this.src = src;
        let isexist = this.isEx();
        if(!isexist)return;
        this.readMethod()
    }
    isEx(){
        if(!existsSync(this.src))  return;
        let isfile = statSync(this.src).isFile();
        if(!isfile)return;
        return isfile;
    }
    readMethod(){
        //读取  判断小文件 大文件
        if(statSync(this.src).size>initSize){
            //大文件   流的方式
            console.log("stream")
            this.readStream()
        }else{
            //小文件  块的方式读取
            console.log("block")
            this.readBlock()
        }
    }
    readStream(){
        //流 水龙头开关 
        let rs = createReadStream(this.src);
        let str="";
        rs.on("data",chuck=>{
            str+=chuck;
        })
        rs.on("end",()=>{
            console.log(str)
        })
    }
    readBlock(){
        readFile(this.src,(err,data)=>{
            console.log(data.toString())
        })
    }
}
// new ReadFile("./index.html")
new ReadFile("./1.mp3")
2、根据文件大小 拷贝文件(管道流 块)
/**@筱淑
 * 文件的拷贝
 */
const fs = require("fs");
let bigSize = 20*1024;
//俩个参数  src  dist
// 1、判断路径是否存在
// 如果存在  判断是文件
// 如果是文件  标准比较大小
// 大文件  流
// 小文件  快
class copyFile{
    //src源路径  dist目标路径
    constructor(src,dist){
        this.src = src;
        this.dist = dist;
        //路径存在 并且 还是个文件
        let isexist = this.isEx();
        if(!isexist){
            return;
        }

        this.copyMethod()
    }
    isEx(){
        //路径是否存在
        if(!fs.existsSync(this.src)){
            return;
        }
        //判断当前路径是不是文件
        let isfile = fs.statSync(this.src).isFile();
        if(!isfile){
            return;
        }
        //是文件 return 文件
        return isfile;
    }
    copyMethod(){
        //根据文件大小 选择拷贝方式
        if(fs.statSync(this.src).size>bigSize){
            //大文件 流的方式拷贝
            console.log("stream")
            let rs = fs.createReadStream(this.src);
            let ws = fs.createWriteStream(this.dist);
            rs.pipe(ws)
        }else{
            console.log("block")
            // 小文件的拷贝  块/buffer流拷贝
            fs.copyFileSync(this.src,this.dist)
            // fs.appendFileSync()
        }
    }
}

new copyFile("./index.html","./index1.html")
new copyFile("./1.mp3","./2.mp3")
3、利用递归-拷贝文件夹
/**@筱淑
 * 文件夹的拷贝
 */
//copyDir  拷贝文件夹   ctr+c  ctr+v的实现
const fs = require("fs");
const path = require("path");
// fs.unlinkSync("./index.js")   //删除文件
// fs.rmdirSync("./aaa")   //只能  删除空文件夹
// fs.mkdirSync("./aaa")  //创建一个文件夹
/**
 * 文件夹 也称为目录
 * @param {源目录} src 
 * @param {目标目录} dist 
 */
function copyDir(src,dist){//abc  abc1
    if(!fs.existsSync(src)){//判断源目录是否存在
        // 不存在 直接中断函数
        return;
    }
    if(!fs.existsSync(dist)){//创建abc1空目录
        // 判断目标目录是否存在  不存在创建目录
        fs.mkdirSync(dist) 
    }
    //读取abc'目录下面的  子目录/子文件
    let childs = fs.readdirSync(src);//[ '1.txt', '2.txt', 'a', 'b', 'c' ]
    // 遍历子路径
    childs.forEach(item=>{
        // 拼接子路径
        let childpath = path.join(src,item);//  abc\1.txt
        //判断子路径是否是文件
        let isfile = fs.statSync(childpath).isFile();
        if(isfile){//如果是文件
            // 用文件的拷贝方式
            fs.copyFileSync(path.join(src,item),path.join(dist,item))
        }else{
            //如果是文件夹 递归拷贝文件夹
            copyDir(path.join(src,item),path.join(dist,item))  //abc/a   abc1/a
        }
    })
}
// abc已经存在的目录   实现ctr+c   ctr+v
copyDir("./abc","./abc1")
4、利用递归-删除文件夹
/**@筱淑
 * delete  删除文件夹
 * @param {删除的文件目录} src 
 * unlink  删除文件
 * rmdirSync  删除空目录
 */
const fs = require("fs");
const path = require("path");
function delDir(src){//abc     abc/a
    if(!fs.existsSync(src)){
        return;
    }
    let childs = fs.readdirSync(src);//[1.txt,a,b]
    //forEach 遇到空数组 直接逃过
    childs.forEach(item=>{
        let childpath = path.join(src,item);
        if(fs.statSync(childpath).isDirectory()){
            //文件夹  abc/a
            delDir(childpath)
        }else{
            //文件  abc/1.txt
            fs.unlinkSync(childpath)
        }
    })
    fs.rmdirSync(src)
}
delDir("./abc")
5、利用递归-读取文件夹的内容 生成json文件
/**@筱淑
 * 传递 文件夹参数  生成json数据并导入到 json文件
 */
const fs = require("fs");
const path = require("path");
function getJson(src){
    let childs = fs.readdirSync(src);//[a.txt,a,b]
    let res=[];
    childs.forEach(item=>{
        let childpath= path.join(src,item);
        let isfile = fs.statSync(childpath).isFile();
        let obj= {
            "singlePath": childpath,
            "isFile": isfile,
            "fileName": item,
            "children": isfile?null:getJson(childpath)
        }
        res.push(obj)
    })
    return res;
}
function readFload(src){
    fs.writeFileSync("./index.json",JSON.stringify(getJson(src)))
}
readFload("./abc")  //生成json文件


6、利用递归-读取json数据 生成文件夹目录
/**@筱淑
 * 根据所给的json数据 生成对应的文件夹
 */
 
const fs = require("fs");
const path = require("path");
const {data1} = require("./dir");
function getDir(obj){//是一个对象
    if(obj.dirname){//文件夹  目录data
        fs.mkdirSync(obj.dirname)
        obj.children.forEach(item=>{//item是一个对象  aaa  a.txt
            if(item.dirname){//文件夹  aaa
                item.dirname = path.join(obj.dirname,item.dirname)
            }else{//文件
                item.filename = path.join(obj.dirname,item.filename)
            }
            getDir(item)
        })
    }else{//文件
        fs.writeFileSync(obj.filename,JSON.stringify(obj.children))
    }
}
getDir(data1)

7、利用递归-创建文件夹
8、文件的合并
/**@筱淑
 * 根据所给的文件信息 合并为一个文件
 */
const fs = require("fs");
const path = require("path");
class MergeFile {
    constructor(dist, opt) {
        this.dist = dist;
        this.opt = opt;
        this.init()
    }
    async init() {//首先拿到opt所有的内容
        let js = ``, css = ``, html = ``;
        for (let item of this.opt) {
            //如果是js  读取js的内容 并存储
            if (item.type === "js") {
                js = await this.getData(item.path)
            } else if (item.type === "css") {
                css = await this.getData(item.path)
            } else if (item.type === "html") {
                html = await this.getData(item.path)
            }
        }
        html =  html.replace("{{style}}",``).replace("{{script}}",``);
        console.log(html)
        fs.writeFile(this.dist,html,err=>{
            if(err) console.log(err);
            console.log("成功写入")
        })
    }
    getData(src) {
        return new Promise((resolve, reject) => {
            fs.readFile(src, (err, data) => {
                if (err) {
                    reject(err);
                    return;
                }
                resolve(data.toString())
            })
        })
    }
}
new MergeFile("./src/index.html", [

你可能感兴趣的:(fs,node)