Node中的Buffer缓冲区和fs文件系统

Buffer（缓冲区）:在数据传输过程中缓冲数据的

结构和操作的方法和数组类似，但是数组中不能存储二进制的文件，而buffer就是用来存储二进制的数据的。
使用buffer不需要引入模块，直接使用即可。
在buffer中存储的都是二进制数据，但是显示时都是以16进制的形式显示的，每一个元素的范围是00 – ff。
只要是在页面或者控制台输出，一定是十进制。

 var str = 'Hello xiaoyang';
    //将一个字符串保存到buffer中
    var buf = Buffer.from(str);

创建一个大小size的buffer,通过索引可以来操作buf中的元素
Buffer的大小一旦确定，则不能修改，Buffer实际上是对底层内存的直接操作

 var buf2 = Buffer.alloc(size);

 //创建一个大小为size的buffer，但是其中可能含有敏感数据
  var buf2 = Buffer.allocUnsafe(size);

fs文件系统

——简单来说就是用过Node来操作系统中的文件
——在Node中，与文件系统的交互非常重要的，副武器的本质就是将本地的文件发送给远程的客户端
——Node通过fs模块来和问纪检系统进行交互，该模块提供了一些标准文件访问API来打开、写入、读取文件，以及与其交互
——使用fs模块需要先引入
——fs模块中所有的操作都有两种形式可供选择，带Sync的为同步，不带的为异步（有回调函数）

 var fa = require('fs');

同步文件的写入过程

var fs = require('fs');
    //1.打开文件
     var fd = fs.openSync(path,flags,mode);
    // -path 要打开文件的路径
    // -flags 打开文件要做的操作类型
    //   'r' 只读的  'w' 可写的 ‘a’打开文件用于追加内容
    // -mode 设置文件的操作权限，一般不传   
    //该方法返回一个文件的描述符作为结果，我们可以通过该描述符来对文件进行各种操作 

    //2.向文件里写入内容
    fs.writeSync(fd,string，position，encoding);
    // -fd 文件的描述符，需要传递要写入文件的描述符
    // -string 要写入的内容
    // -position 写入的起始位置
    // -encoding 写入的编码，默认UTF-8

    //3.保存并关闭文件
    fs.closeSync(fd);

   //实例
     var fs = require('fs');
     var fd = fs.openSync('hello.txt','w');
     fs.writeSync(fd,'我现在好饿');
     fs.closeSync(fd);

异步文件（有回调函数）的写入过程（异步不会阻塞进程）

    var fs = require('fs');
        //1.打开文件
        fs.open('hello.txt','w',function(err,fd){
            //异步调用的方法，结果都是通过回调函数的参数返回的
            // -回调函数两个参数：
            //                 err: 错误对象，如果没有错误则为null;
            //                  fd: 文件的描述符
                if(!err){//如果没有出错，则对文件进行写入操作
                    //2.向文件里写入内容
                    fs.write(fd,'我还是好饿',function(err){
                        if(!err){
                            console.log('写入成功');                         
                        }
                    // //3.保存并关闭文件
                    fs.close(fd,function(err){
                        if(!err){
                            console.log('文件已关闭');                        
                        }
                    })
                    })
                }
        })

简单文件写入

 fs.write(file,data,options,callback);
 fs.writeSync(file,data,options);

//实例
   var fs = require('fs');
        fs.writeFile('hello.txt','你今天过得还好么',{flag:'a'},function(err){
            if(!err){
                console.log('写入成功了');               
            }
        })

同步、异步、简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出

流式文件写入

     var fs = require('fs');
           //创建一个可写流
           var ws = fs.createWriteStream('hello.txt');
        //可以通过监听流的open 和close事件来监听流的打开和保存
        ws.once('open',function(){
            //once(事件字符串，回调函数)：可以为对象绑定一个一次性事件，改时间将会在触发一次后自动失效
            console.log('流打开了');
        });
        //通过ws向文件中输入内容
        ws.write('通过可写流写入文件的内容');
        ws.write('为啥你不写进去');
        //关闭流
        ws.end();
        ws.once('close',function(){
            console.log('流关闭了');
        });

简单文件的读取

    var fs = require('fs');
        fs.readFile('hello.txt',(err,data)=>{
            if(!err){
                console.log(data);            
                  }
        })

流式文件读取（适用于一些大的文件）

可以分多次将文件读取到内存中

        var fs = require('fs');
       //创建一个可读流
       var rs = fs.createReadStream('hello.txt');
       //监听流的开启和关闭
       rs.once('open',function(){
           console.log('流开启了')
       })
       rs.once('close',function(){
           console.log('流关闭了')
       })
       //如果要读取一个可读流中的数据，必须要为可读流绑定一个data事件，data事件绑定完毕，它就会自动开始读取数据
       rs.on('data',function(data){
        console.log(data);//每次度65536字节
           })

//将可读流和可写流的信息相互传递
rs.pipe(ws);

fs的其他方法

（1）检查一个文件是否存在 fs.exists(path);
（2）获取文件状态 fs.stat(path,function(err,stat){})
（3）删除文件fs.unlink(path,callback)
（4）列出文件fs.readdir(path,callback)
（5）截断文件fs.truncate(path,len,callback):将文件修改为指定长度
（6）建立目录fs.mkdir(path,callback)
（7）删除一个目录fa.rmdir(path,callback)
（8）对文件重命名fs.rename(oldPath,newPath,callback)
（9）监事文件的修改fa.watchFile(filename,option,listener)
当文件发生变化是listener回调函数会执行