node学习七：文件操作

文件操作涉及到了nodejs设计思想中的异步I/O（文件操作、网络操作）

异步编程：

异步I/O input/output：

1、文件操作
2、网络操作

在浏览器中也存在异步操作：

1、定时任务
2、事件处理
3、Ajax回调处理

js的运行时单线程的
单线程存在缺点：一旦遇到一个耗时的任务，比如循环操作一万次，比较消耗cpu，可能会导致ui操作的阻塞
所以引入事件队列机制
Node.js中的事件模型与浏览器中的事件模型类似
单线程+事件队列
基于回调函数的编码风格

导入fs文件系统模块：

const fs = require('fs');

文件操作：

文件信息获取：

异步操作方式的文件信息获取：

fs.stat(path[, options], callback)：

fs.stat('./data.txt',(err,stat) => {
    // 一般回调函数的第一个参数是错误对象，如果err为null,表示没有错误，否则表示报错了
    if(err) return ;
    console.log(err);
})

fs.stat('./data1.txt',(err,stat) => {
    // 一般回调函数的第一个参数是错误对象，如果err为null,表示没有错误，否则表示报错了
    console.log(err);
    if(err) return ;
})

stats.isFile()：

fs.stat('./data.txt',(err,stat) => {
    // 一般回调函数的第一个参数是错误对象，如果err为null,表示没有错误，否则表示报错了
    if(err) return ;
    // console.log(err);
    if(stat.isFile()){
        console.log("文件");
    }else if(stat.isDirectory()){
        console.log("目录");
    }
})

stats.isDirectory()：

fs.stat('./hello',(err,stat) => {
    // 一般回调函数的第一个参数是错误对象，如果err为null,表示没有错误，否则表示报错了
    if(err) return ;
    // console.log(err);
    if(stat.isFile()){
        console.log("文件");
    }else if(stat.isDirectory()){
        console.log("目录");
    }
})

stats.atime 文件访问时间
stats.ctime 文件的状态信息发生变化的时间（比如文件的权限）
stats.mtime 文件数据发生变化的时间
stats.birthtime 文件创建的时间

同步操作方式的文件信息获取：

// 同步操作
let ret = fs.statSync('./data.txt');
console.log(ret);

同步操作（要执行完此时的操作才能继续后面的操作）里ret的值和异步操作里回调函数里的参数stat的值是一样的

读文件操作：

导入path、fs模块：

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

异步操作方式的读文件：

fs.readFile(path[, options], callback)：

let strpath = path.join(__dirname,'data.txt');
fs.readFile(strpath,(err,data)=>{
    if(err) return;
    console.log(data);
    console.log(data.toString());
});

// 如果有第二个参数并且是编码，那么回调函数获取到的数据就是字符串
// 如果没有第二个参数，那么得到的就是Buffer实例对象
let strpath = path.join(__dirname,'data.txt');
fs.readFile(strpath,'utf8',(err,data)=>{
    if(err) return;
    // console.log(data.toString());
    console.log(data);
});

同步操作方式的读文件：

let strpath = path.join(__dirname,'data.txt');
let ret1 = fs.readFileSync(strpath);
console.log(ret1);
let ret2 = fs.readFileSync(strpath,'utf8');
console.log(ret2);

写文件操作：

导入path、fs模块：

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

异步操作方式的写文件：

fs.writeFile(file, data[, options], callback)：

let strpath = path.join(__dirname,'data.txt');
fs.writeFile(strpath,'hello nihao','utf8',(err)=>{
    if(!err){
        console.log('文件写入成功');
    }
});

data.txt文件的变化：

let strpath = path.join(__dirname,'data.txt');
let buf = Buffer.from('hi');
fs.writeFile(strpath,buf,'utf8',(err)=>{
    if(!err){
        console.log('文件写入成功');
    }
});

data.txt文件的变化：

同步操作方式的写文件：

// 同步操作
let strpath = path.join(__dirname,'data.txt');
fs.writeFileSync(strpath,'tom and jerry');

大文件操作（流式操作--一部分一部分的处理）：

导入path、fs模块：

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

fs.createReadStream(path[, options])：

let spath = path.join(__dirname,'../03-source','file.zip');
let dpath = path.join('C:\\Users\\www\\Desktop','file.zip');

let readStream = fs.createReadStream(spath);
let writeStream = fs.createWriteStream(dpath);
let num = 1;
readStream.on('data',(chunk)=>{
    num++;
    writeStream.write(chunk);
});

readStream.on('end',()=>{
    console.log('文件处理完成'+num);
});

let spath = path.join(__dirname,'../03-source','file.zip');
let dpath = path.join('C:\\Users\\www\\Desktop','file.zip');

let readStream = fs.createReadStream(spath);
let writeStream = fs.createWriteStream(dpath);
// pipe的作用直接把输入流和输出流
readStream.pipe(writeStream);

let spath = path.join(__dirname,'../03-source','file.zip');
let dpath = path.join('C:\\Users\\www\\Desktop','file.zip');
fs.createReadStream(spath).pipe(fs.createWriteStream(dpath));

目录操作：

导入path和fs模块：

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

创建目录：
fs.mkdir(path[, mode], callback)

// 创建目录
fs.mkdir(path.join(__dirname,'abc'),(err)=>{
    console.log(err);
});

fs.mkdirSync(path[, mode])

fs.mkdirSync(path.join(__dirname,'abc'));

读取目录：
fs.readdir(path[, options], callback)

// 读取目录
fs.readdir(__dirname,(err,files)=>{
    files.forEach((item,index)=>{
        fs.stat(path.join(__dirname,item),(err,stat)=>{
            if(stat.isFile()){
                console.log(item,'文件');
            }else if(stat.isDirectory()){
                console.log(item,'目录');
            }
        });
    });
});

fs.readdirSync(path[, options])

let files = fs.readdirSync(__dirname);
files.forEach((item,index)=>{
    fs.stat(path.join(__dirname,item),(err,stat)=>{
        if(stat.isFile()){
            console.log(item,'文件');
        }else if(stat.isDirectory()){
            console.log(item,'目录');
        }
    });
});

删除目录：
fs.rmdir(path, callback)

// 删除目录
fs.rmdir(path.join(__dirname,'abc'),(err)=>{
    console.log(err);
});

fs.rmdirSync(path)

fs.rmdirSync(path.join(__dirname,'abc'));

文件操作案例（初始化目录结构）：

/*
    文件操作案例（初始化目录结构）
*/
const path = require('path');
const fs = require('fs');

let root = 'C:\\Users\\www\\Desktop';
let fileContent = `
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
    <div>welcome to this</div>
</body>
</html>
`;

// 初始化数据
let initData = {
    projectName : 'mydemo',
    data : [{
        name : 'img',
        type : 'dir'
    },{
        name : 'css',
        type : 'dir'
    },{
        name : 'js',
        type : 'dir'
    },{
        name : 'index.html',
        type : 'file'
    }]
}

// 创建项目跟路径
fs.mkdir(path.join(root,initData.projectName),(err)=>{
    if(err) return;
    // 创建子目录和文件
    initData.data.forEach((item)=>{
        if(item.type == 'dir'){
            // 创建子目录
            fs.mkdirSync(path.join(root,initData.projectName,item.name));
        }else if(item.type == 'file'){
            // 创建文件并写入内容
            fs.writeFileSync(path.join(root,initData.projectName,item.name),fileContent);
        }
    });
});