NodeJs基础（文件系统）

文件系统

在Node中，与文件系统的交互是非常重要的，服务器的本质就是将本地的文件发送到远程的客户端

Buffer（缓冲区）

Node中提供的新的对象，这个对象可以在node中直接使用，不需要引入；和js中的数组（js数组缺点：无法存储二进制数据）非常相似；Buffer中只能保存二进制数据

• 在Buffer中每一个元素都是二进制数据，但是直接打印时，会以十六进制显示；Buffer中每一个范围在00 ff之间（0 255），对应的二进制是00000000 11111111
  • buf.length 获取的是内容占用内存的大小，而不是长度；每个汉字在内存中占用3个字节
• 将一个字符串转换为一个Buffer
  • var buf = Buffer.from('Hello')；
• Buffer转换为字符串
  • var str = buf.toString();
• 创建一个Buffer对象
  • var buf = Buffer.alloc(size);
    • 分配内存并初始化
    • size 是Buffer的大小，size的单位是kb，可直接计算；（alloc：分配）
• 向buf中添加元素
  • 通过索引对buffer中的元素进行操作
  • 只要数字输出如console.log(10)/alert(10)就是会以十进制输出
  • Number的toString(2/8/16)可以指定数字的进制
  • Buffer的大小一旦确认则不能修改；因为Buffer是直接对内存进行操作；为了性能更好所以大小都是不能改变
  • 数字的值不要超过255，超过会溢出
• 遍历

    for(var i=0; i < Buffer.length; i++){ 
        console.log(buf[i]) 
    }  

• Buffer.allocUnsafe(size)
  • 创建一个指定大小的Buffer，不初始化。该Buffer中可能含有敏感数据
  • 比Buffer.alloc(size) 性能高，但是不安全

fs 文件系统

Node通过fs模块和文件系统进行交互，使用文件系统必须先引入fs模块；fs模块属于node的核心模块，不需下载，直接引入即可

• fs模块操作都有同步和异步调用
  • 同步会阻塞系统；异步不会阻塞系统
  • 异步肯定会有回调函数
• fs模块中所有方法都有两份版本
  • 不带sync，异步版本
  • 带sync，同步版本
• 文件写入
  1. 打开文件 如果没有文件会自动新建文件

fs.open(path,flags[,mode],callback);  
fs.openSync(path,flags[,mode]);  

参数：
path 打开文件的路径
flags 对文件操作的类型，需要一个字符串作为参数 'r'/'w'
mode 设置文件的权限（主要针对Linux），一般不传
callback 回调函数，所有的异步方法必有回调函数
同步操作依靠返回值：当打开文件以后，会返回一个文件描述符作为返回值；文件描述符： 在形式上是一个非负整数。实际上，它是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。

2. 写入内容并保存

    fs.write(fd,string[,position[,encoding]],callback);    
    fs.writeSync(fd,string[,position[,encoding]]);    

参数：
fd：要写入的文件的描述符
string：要写入的内容
position：写入的起始的位置
encoding：写入文件的编码 默认utf-8

3. 关闭文件

    fs.close(fd,callback);    
    fs.closeSync(fd); 

参数：
fd：要关闭的文件的文件描述符

异步文件写入

callback 回调函数，所有的异步方法必有回调函数
异步方法都是通过回调函数（的参数形式）返回结果
回调函数有两个参数：

• err 错误信息，如果该对象存在，则证明出错了（错误优先原则）
• fd 文件操作符，代表此时打开的文件
  打开文件代码：

      fs.open('fileName','w',function(err,fd){
        //如果没有错误
        if(!err){
            //写入文件
            fs.write(fd,'string',function(err){
                if(!err){
                //输出一句话
                console.log('写入成功')
                }

            //关闭文件
            fs.close(fd,function(err){
                if(!err){
                //输出一句话
                console.log('关闭成功') 
                }
            });
        });
        }
      }); 

简单文件写入

    fs.writeFile(filePath,data[,options],callback)  
    fs.writeFileSync(filePath,data[,options])

参数：
filePath：要写入的文件的路径
data：要写入的数据（String或Buffer）
options：配置选项，需要一个对象作为参数，一般不需要

• encoding 文件的编码 默认--utf8
• mode 文件的权限（一般不写） 默认--0666
• flag 操作的类型 默认 'w'
  callback 写入完成以后调用的函数

    fs.writeFile('filePath','内容',function(err){  
        if(!err){  
            console.log('写入成功')  
        }else if(err){  
            console.log(err)  
        }  
    })  

文件的操作符

• w 对文件进行写操作 文件不存在则报错
• r 对文件进行读操作 文件不存在则新建
• a 对文件进行追加操作 文件不存在则新建

流式文件写入

• 传统的写入方式都是一次性将内容写入到文件中，如果文件过大，先将内容全部加载进内存后写入，这样在写入较大的数据时，容易导致内存溢出或者性能较差
• 所以我们需要引入流式文件写入来处理较大的文件
• 流主要使用两种
  • 可写流
  • 可读流

    //创建可写流  
    var ws = fs.createWriteStream('filePath');  
    
    //监视流的状态，可以通过为流绑定open和close事件来监视流的状态（多次）   
    ws.on('open',function(){  
        console.log('流打开了')  
    });  
    
    ws.on('close',function(){  
        console.log('流关闭了')  
    }) 
    //once()可以为一个对象绑定一个一次性的事件，该事件将会在触发一次后自动失效（一次） 
    ws.once('open',function(){  
        console.log('流打开了')  
    });  
    
    ws.once('close',function(){  
        console.log('流关闭了')  
    }) 
    //通过可写流向文件写入内容
    ws.write('datas')
    
    //关闭流
    ws.close(); 此方法会导致数据缺失 
    ws.end(); 可以将数据写入到文件，并关闭流

文件读取

1. 同步文件读取

2. 异步文件读取

3. 简单文件读取

    fs.readFile(path[,options],callBack);  
    fs.readFileSync(path[,options]);  

• 参数：
  • path：读取文件的路径
  • options：配置对象
    • encoding：指定打开文件的编码，默认是null
    • flag：文件的操作类型，默认是 r
  • callBack：回调函数，通过回调函数返回读取到的数据
    • err：错误对象
    • data：返回的数据（Buffer）

    fs.readFile('fileName',function(err,date){  
        if(!err){
            console.log(data);  
    
            //将读取到的数据写入到磁盘的其他位置
            fs.writeFile('path',data,function(err){
                if(!err){   
                    console.log('写入成功')
                }  
            })  
        }  
    })  

4. 流式文件读取

• 流式文件读取，适合较大的文件

    //创建一个可读流  
    var rs = fs.creatReadStream('fileName');     
    var ws = fs.creatWritStream('fileName');  
    rs.pipe(ws);  

    //监听rs的打开和关闭事件  
    rs.once('open',function(){    
        console.log('');    
    });      
    rs.once('close',function(){    
        console.log('');    
    });   

    //通过可读流读取一个文件，必须为流绑定data事件，当绑定data事件以后，流会自动读取     
    rs.on('data',function(data){    
        console.log(data);    
    });    

其他操作

• 验证路径是否存在
  fs.existsSync('path');
  • 返回值：文件存在为true；文件不存在为false
  • 同步和异步方法各有特点，具体情况区分使用
• 用来获取一个文件的状态

     fs.stat(path,callBack);  
     fs.statSync(path);    

参数：

• path：要获取状态文件的路径
• callBack：
  • err：错误对象
  • stats：状态对象，用来描述文件的状态
• 删除一个文件

    fs.unlink('path',callBack);      
    fs.unlinkSync('path');    

• 读取当前目录下的所有文件和文件夹的列表

    fs.readdir('path'[,options],callBack);  
    fs.readdirSync('path'[,options]);    

• 截断文件，使文件变成指定大小

    fs.truncate('path',length,callBack);  
    fs.truncateSync('path',length);    

• 创建文件夹

    fs.mkdir('path'[, options],callBack);  
    fs.mkdirSync('path'[, options]);  

• 删除文件夹

    fs.rmdir('path',callBack);  
    fs.rmdirSync('path');    

• 重写文件和目录名：可以实现剪切功能

    fs.rename('oldPath'，'newPath'，callBack)；    
    fs.renameSync('oldPath'，'newPath')；  

• 监听文件 每隔一段时间去判断文件是否发生改变
  fs.watchFile(filename[,option],listener);
  • listener：回调函数，传递两个参数，是stats类型的对象
    • current：表示当前文件的状态
    • previous：表示修改之前文件的状态