nodejs学习第一天（文件的导入导出,读写文件,流）

文件的导入导出

nodejs使用的commonjs规范
导出 module.exports

let a = 1
let b = "b"
console.log("王王王")        
exports.b=b;                 // 使用exports只能导出一个
module.exports.a = a         // 这个和上面的一样

// 或
module.exports = { a,b }     // 当使用这种写法，可以导出多个变量，并且，如果存在三种写法都在一个结束文件，那么就只会导出module.exports的内容
							 // 因为别人在导入这个js文件的时候，导入的对应的就是module.exports

导入 require

let c = require("./index.js")     // 使用这种方法导入就是能够执行模块中的代码，并且返回接口对象，就是导出的内容
console.log(c);  //  王王王 { a:1 , b:'b' }   导入这个模块会先执行这个模块的代码

如果导入两次呢，会如何
即使导入两次，但也只是执行一次这个导入的模块
比如

let c = require("./index.js")
let d = require("./index.js")
console.log(c)
console.log(d)
console.log(c == d);

// 结果
王王王  // 模块代码里的输出
王王王 { a:1 , b:'b' } // c
王王王 { a:1 , b:'b' } // d
true

读写文件

node读写文件必须需要使用fs文件读写模块
读写文件有同步和异步两种方法

读取文件
同步

let fs = require('fs')      // 导入
// 同步
// 使用 readFileSync
// 下面参数分析，第一个参数是文件路径，第二个参数flag代表对这个文件是读是写，encoding代表获取出来的编码
// r 代表只可读
let fd = fs.readFileSync('./holleWork.txt',{flag:"r",encoding:"utf-8"})
console.log(fd);   

异步

// 异步
// 使用 readFile 没有返回值，结果在回调函数那里，回调函数必填
//下面参数分析，第一个：路径，第二个：option（选填），第三个：回调函数
fs.readFile('./holleWork.txt',{flag:"r",encoding:"utf-8"},function (err, data) {
  if (err) {
    //错误
  } else{
    console.log(data);
  } 
  console.log(456);
})
console.log(123);

//结果
123
aaa
456

把上面的异步封装成promise形式

function readfile(url) {
  return new Promise( function(resolve, reject) {
    fs.readFile(url,{flag:"r",encoding:"utf-8"},function (err, data) {
      if (err) {
        reject(err)
      } else{
        resolve(data)
      } 
  })
  })
}
let w1 = readfile("./holleWork.txt")
w1.then( function (res){
  console.log(res);
})

// 或者可以使用aysnc调用，当多个文件嵌套的时候
async function read() {
  let a = await readfile("./holleWork.txt")  // index2
  let b = await readfile("./"+ a + ".txt")   // index3
  let c = await readfile("./"+ b + ".txt")   // hellowork
}
read()

---

写入文件
使用 writeFile

let fs = require("fs")
let content = "今晚吃老虎"
// w 是覆盖写入  a 是追加写入
// 参数说明。第一个：路径  第二个：写入的内容  第三个：option（写入方式，编码），第四个，回调函数
fs.writeFile("./aa.txt",content,{flag:"a",encoding:"utf-8"},function (err){
  if (err) {
    console.log("写入失败");
  }else{
    console.log("成功") 
  }
})

读取与写入目录
创建目录 mkdir
读取 readdir

let fs = require("fs")
// 使用
// 参数，第一个： 路径  第二个：回调函数
fs.readdir("../读取目录并且结合读写文件",function (err, files) {
  if (err) {
    
  }else{
    console.log(files);
  }
})

删除文件 unlink
删除目录 rmdir

// 删除
// 参数，第一个：路径  第二个：回调函数，没有参数
fs.unlink("./bb.txt",function () {
  console.log("成功");
  
})

buffer缓存区的使用
由于js的数组不能进行二进制的操作，所以使用buffer，它的作用就是开辟一段固定大小的内存，里面就是进行二进制的操作，但我们使用的时候显示出来的是16禁制的样子，里面的内容是有顺序的
使用：

// 将字符串转换成buffer对象
let aa = "aa"
let bu = Buffer.from(aa)
console.log(bu);  // <Buffer 61 61>  由于两个值

// 正常使用情况
// 先创建缓存区域
let buf = Buffer.alloc(10)
buf[0] = "99"
console.log(buf); //<Buffer 63 00 00 00 00 00 00 00 00 00>

结合读取目录，读写文件

let fs = require("fs")
let readfile = require("../文件读写/index")
let  write = require("../文件写入与删除/index")

let all = "all.txt"
fs.readdir("../读取目录并且结合读写文件",function (err, files) {
  if (err) {
    
  }else{
    files.forEach( async function (filename,i ){
      let content = await readfile("./"+filename)
      await write("./"+ all , content )
    })
  }
}) 

输入输出 readline

let readline = require("readline")

// 创建接口实例
let r1 = readline.createInterface({
  output:process.stdout,     // 代表终端输出
  input:process.stdin  		 // 代表终端输入
})

// 设置r1提问事件
let content = "今晚吃了什么"
r1.question(content, function (answer) {
  console.log(answer);
  //调用结束程序
  r1.close()
})

// close事件监听
r1.on("close",function () {
  //结束程序
  process.exit(0)
})

流的是使用

当需要读写大型文件时候，就需要用到流，它的原理就像管道输送水一样，能输送多少算多少
流式写入操作
就是一点一点写入
其实单单只有write方法也可以执行写入

let fs = require("fs")

// 创建一个可以写入的流，也就是写进去的文件与配置（写入方式flag，编码）
let w1 = fs.createWriteStream("out.txt",{flags:"w",encoding:"utf-8"})

// 打开文件
w1.on("open",function () {
  console.log("文件打开");
})

// 监听文件准备被写入事件
w1.on("ready",function () {
  console.log("文件准备被写入");
})

// 文件写入
w1.write('我是内容1',function (err) {
  if (err) {
  }else{
    console.log("写入成功1");
  }
})
// 文件写入
w1.write('我是内容2',function (err) {
  if (err) { 
  }else{
    console.log("写入成功2");
  }
})
// 文件写入3
w1.write('我是内容3',function (err) {
  if (err) {
  }else{
    console.log("写入成功3");
  }
})

// 文件写入关闭
w1.end(function () {
  console.log("文件写入关闭");
})
// 程序关闭
w1.on("close",function () {
  console.log("完成关闭");
})

流式读操作

// 创建读的流来源
let w1 = fs.createReadStream("./out.txt",{flags:"r",encoding:"utf-8"})

// 打开文件
 w1.on("open",function(){
    console.log("读取");
 })

 w1.on("data",function( res ){
  console.log(res);
  console.log("数据读完成");
 })

 w1.on("close",function(){
  console.log("读取结束");
  
})

结流合读写对大文件进行操作

// 创建读的流来源
let w1 = fs.createReadStream("./01-(了解)小程序开发介绍.mp4",{flags:"r"})
let w2 = fs.createWriteStream("./bb.mp4",{flags:"w",encoding:"utf-8"})

// 打开文件
 w1.on("open",function(){
    console.log("打开文件");
 })

 w1.on("data",function( res ){
  console.log("数据读取");
  console.log(res);
  w2.write(res,function(){               // 读取结束写入
    console.log("单批数据写入成功");
  })
 })

 w1.on("close",function(){
  console.log("读取结束");
  w2.end()                               // 结束读取
})

其实有封装好的方法可以直接进行读写，也叫管道流，pipe（）

let w1 = fs.createReadStream("./01-(了解)小程序开发介绍.mp4",{flags:"r"})
let w2 = fs.createWriteStream("./cc.mp4")

 w1.on("open",function(){
    console.log("打开文件");
 })
 w1.on("close",function(){
  console.log("读取结束");
})
// 进行读写
w1.pipe(w2)

链式流，流得压缩和解压缩操作

let fs = require('fs')
let zlib = require('zlib')

// 压缩过程
// fs.createReadStream('aa.txt').pipe(zlib.createGzip()).pipe(fs.createWriteStream('aa.gz'));   

// 解压缩过程
fs.createReadStream('aa.gz').pipe(zlib.createGunzip()).pipe(fs.createWriteStream('./bb.txt'))