路线的操作详解,学习种类

Nodejs基础api

1、path
path模块提供了众多实用的工具函数,用于拍卖公事与目录的路子,上边是它的api:

  • normalize 方法能够出口规范格式的path字符串
  • join 方法用于拼接path字符串
  • resolve 方法用于将相对路径解析为绝对路径
  • name 方法用于查看文件名
    • basename查看文件名
    • dirname查看所在路径
    • extname查看扩张名
  • parse与format,parse用于将1个门路字符串重临成二个对象,而format则正好相反,假诺偶尔你须求修改贰个路线的话,就能够先parse修改之后再format回去
  • delimiter
    提供差别系统下的分隔符,windows系统(;)和posix(:)系统一分配隔符差异。sep
    重回各平台的分隔符(Windows,POSIX/)

    //delimiter
    console.log(process.env.PATH)
    ‘C:\Windows\system32;C:\Windows;C:\Program Files\node’

    process.env.PATH.split(path.delimiter)
    [‘C:\Windows\system32’, ‘C:\Windows’, ‘C:\Program
    Files\node\’]

    //sep
    ‘foo\bar\baz’.split(path.sep)
    返回:[‘foo’,’bar’,’baz’]

path路径必要专注的局地地点

  • _dirname、_filename总是回到文件的绝对路径
  • process.cwd( )总是回到执行node命令所在文件夹

2、Buffer(缓冲)
Buffer是global对象的习性,用于拍卖二进制数据流。它的实例类似整数数组,然而它里面是某些0-255的数字(默许用十6进制表示)大小固定。且用C++代码在V8堆外分配物理内部存款和储蓄器

什么实例化Buffer:

  • Buffer.alloc( length ) or Buffer.alloc( length,1 )
  • Buffer.allocUnsafe( length ) //
    它较于alloc的界别是没做早先化,那样速度快,但内部存款和储蓄器块原来有的东西没清空,所以要用fill(
    )于write( )把内部的始末重写一下
  • Buffer.from( [1,2,3] ) or Buffer.form( 字符串 , 编码格式)

以下是它的类的一对常用方法:

  • Buffer.byteLength 重返二个字符串的实在字节长度
  • Buffer.isBuffer( ) 判断是不是时buffer对象
  • Buffer.concat( ) 拼接buffer,传入的参数是一个数组

再看下实例的性质

  • buf.length 重回 buf 在字节数上分红的内部存储器量
  • buf.toString( ) 根据钦赐的字符编码解码 buf 成贰个字符串
  • buf.fill( ) 用于填充buf
  • buf.equals( ) 比较八个buf的始末是或不是同样
  • buf.indexOf( ) 用于查找相称
  • buf.copy( )

3、event
Nodejs全数能接触事件的靶子都以伊芙ntEmitter类的实例,这个指标开放了三个eventEmitter.on()
函数,允许将多少个或多个函数绑定到会被对象触发的命名事件上。
eventEmitter.on() 方法用于注册监听器,eventEmitter.emit()
方法用于触发事件。

const EventEmiter = require('events');

class triggerEvent extends EventEmiter {}

const ex = new triggerEvent();//实例化

ex.on("error",(err,time) => {
  console.log(err);
  console.log(time)
});//事件绑定

ex.emit("err",new Error("opps!"),Date.now());//手动触发事件,并传两个参数

Nodejs事件的绑定还能用once实行绑定,让事件只触发三遍。
而事件能够由此removeListener(event name,function
name)实行移除,可能选用removeAllListeners(event name)移除全体

肆、fs(文件系统)
fs 模块提供了一些 API,用于以壹连串似标准 POSIX
函数的不二等秘书诀与文件系统进行相互。
富有的文件系统操作都有异步和同步二种样式。
异步格局的末尾四个参数都以形成时回调函数。
传给回调函数的参数取决于具体方法,但回调函数的率先个参数都会保留给那一个

  • fs.readFile( ) 读取文件

 const fs = require("fs");

    fs.readFile("./event.js",'utf8',(err,data) => {
      if(err) {
        throw err;
      } else {
        console.log(data);
      }
    })//异步读取文件

    const data = fs.readFileSync("./event.js",'utf-8');//同步读取文件
    console.log(data);
  • fs.writeFile( ) 写入文件

const fs = require("fs");

const content = Buffer.from("balabalabala");

fs.writeFile("./text",content,err => {
  if(err){
    throw err;
  } else {
    console.log("done !");
  }
})
  • fs.stat( ) 输出文件的stats属性

const fs = require("fs");

fs.stat("stat.js", (err,stats) => {
    if(err) {
      console.log("文件不存在!");
      return;
    } else {
      console.log(stats.isFile());//是否为文件
      console.log(stats.isDirectory());//是否为文件夹
    }
 })
  • fs.watch( ) 监视文件大概文件夹

const fs = require("fs");

fs.watch('./',{
  recursive: true //指明是否全部子目录应该被监视,或只是当前目录。
},(eventType,filename) => {
  console.log("变化类型",eventType);
  console.log("变化的文件名",filename);
})
  • fs.createReadStream( ) 创立数据流,读取数据
    数量是一丢丢流动的,不是百分之百收受,相较于fs.readFile( )会议及展览示愈加高雅

const fs = require("fs");

const rs = fs.createReadStream('./readstream.js');

rs.pipe(process.stdout);//数据导向哪里,stdout就是控制台
  • fs.createWriteStream( ) 成立数据流,写入数据
    fs.createReadStream( ),它是1种优雅的写入数据的章程

const fs = require("fs");

const ws = fs.createWriteStream('./test.txt');

const timer = setInterval(() => {
  const num = parseInt(Math.random() * 10);//取19以内的随机数
  if(num < 8){
    ws.write(num + '');//转换为字符串,因为只能写入buffer或者字符串
  } else {
    clearInterval(timer);//清楚定时器
    ws.end();//结束写入数据流
  }
},1000);//每个一秒写入一段数据

ws.on("finish",() => {
  console.log("done!");
});//监听事件结束

上边还有1部分常用的api:

  • fs.rename( ) 修改文件名
  • fs.unlink( ) 删除文件
  • fs.readdir( ) 读取文件夹下的有着文件名
  • fs.mkdir( ) 创设文件夹
  • fs.rmdir( ) 删除文件夹

path

  • normalize、join 、resolve

const {normalize} = require('path')
//等同于es5
// const normalize = require('path').normalize()

//path.normalize() 方法会规范化给定的 path,并解析 '..' 和 '.' 片段。
console.log(normalize('/usr//local/bin'))
console.log(normalize('/usr//lo/../bin'))
/*
输出
/usr/local/bin
/usr/bin
 */

const {join} = require('path')
//path.join拼接路径
console.log(join('/usr','loc','haha/'))
console.log(join('/usr///','..//lll','sds////'))
/*
输出结果
/usr/loc/haha/
/lll/sds/
 */
  • basename 、extname 、dirname

const {basename,dirname,extname} = require(
    'path'
)

const filePath = '/usr/local/bin/no.txt'

console.log(dirname(filePath))
console.log(basename(filePath))
console.log(extname(filePath))

/*
输出结果:
/usr/local/bin
no.txt
.txt
 */
  • parse 、format

const {parse,format} = require('path')
const filePath = '/usr/local/node_modules/n/p.json'
const ret = parse(filePath)
console.log(ret)
console.log(format(ret))

/*
输出结果:
{ root: '/',
  dir: '/usr/local/node_modules/n',
  base: 'p.json',
  ext: '.json',
  name: 'p' }

/usr/local/node_modules/n/p.json

 */
  • sep 、delimiter 、win32 、posix

const {sep, delimiter, win32, posix} = require('path')
console.log('sep:',sep)
// sep: /
console.log('win.sep:',win32.sep);
// win.sep: \
console.log('PATH:',process.env.PATH)
console.log('delimiter:',delimiter)
// delimiter: :
console.log('win.delimiter:',win32.delimiter)
// win.delimiter: ;

path

  • __dirname、__filename总是回到文件的相对路径
  • process.cwd()总是回到执行node命令所在的文书夹

相对路径(./)

  • 在require方法中连连相对当前文件所在文件夹
  • 在另各市方和process.cwd()1样,相对于node运行文件夹

正文的主要内容是对nodejs提供的片段首要模块,结合官方API实行介绍,遭受精粹的稿子,笔者会附在文中并标明了出处。主要包罗如下多少个模块

 

buffer

Buffter特点:

  • Buffer用于拍卖2进制数据流
  • 实例类似整数数组,大小固定
  • C++代码在V八堆外分配物流内部存款和储蓄器
  • Buffer.alloc()、Buffer.allocUnsafe()、Buffer.from()

console.log(Buffer.alloc(10))
console.log(Buffer.alloc(20))
console.log(Buffer.alloc(5,1))
//不会清空原有的内存
console.log(Buffer.allocUnsafe(5,1))
console.log(Buffer.from([1,2,3]))
console.log(Buffer.from('test'))
console.log(Buffer.from('test','base64'))

console.log(Buffer.from('你好','utf-8'))

/*
<Buffer 00 00 00 00 00 00 00 00 00 00>
<Buffer 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00>
<Buffer 01 01 01 01 01>
<Buffer 00 00 00 00 00>
<Buffer 01 02 03>
<Buffer 74 65 73 74>
<Buffer b5 eb 2d>
<Buffer e4 bd a0 e5 a5 bd>
 */
  • Buffer.byteLength、Buffer.isBuffer()、Buffer.concat()

/*
Buffer.byteLength
Buffer.isBuffer()
Buffer.concat()
 */

console.log(Buffer.byteLength('test'))//4
console.log(Buffer.byteLength('测试'))//6

console.log(Buffer.isBuffer({}))//false
console.log(Buffer.isBuffer(Buffer.from([1,2,3,4])))//true

const buf1 = Buffer.from('this')
const buf2 = Buffer.from('is')
const buf3 = Buffer.from('a')
const buf4 = Buffer.from('concat')

const buf = Buffer.concat([buf1,buf2,buf3,buf4])

console.log(buf)//<Buffer 74 68 69 73 69 73 61 63 6f 6e 63 61 74>
  • buf.length、buf.toString()、buf.fill()、buf.equals()、buf.indexOf()、buf.copy()

/*
buf.length
buf.toString()
buf.fill()
buf.equals()
buf.indexOf()
buf.copy()
 */

var buf = Buffer.from('buf.length')
console.log(buf.length)

buf = Buffer.allocUnsafe(5)
buf[0]=22
console.log(buf.length)

console.log(buf.toString('base64'))
console.log(buf.toString('utf-8'))

const buf3 = Buffer.allocUnsafe(10)

console.log(buf3)
console.log(buf3.fill(10,2,6))

const buf4 = Buffer.from('test')
const buf5 = Buffer.from('test')
const buf6 = Buffer.from('test!')

console.log(buf4.equals(buf5))
console.log(buf4.equals(buf6))

console.log(buf4.indexOf('es'))
console.log(buf4.indexOf('esa'))

/*
10
5
FikQlNU=
)��
<Buffer 81 00 00 00 a9 29 10 94 01 00>
<Buffer 81 00 0a 0a 0a 0a 10 94 01 00>
true
false
1
-1
 */

处理乱码:string_decoder

const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')
const buf = Buffer.from('中文字符串!理你理你')

for (let i = 0; i < buf.length; i += 5) {
    const b = Buffer.allocUnsafe(5)
    buf.copy(b, 0, i);
    console.log(b.toString())
}

for (let i = 0; i < buf.length; i += 5) {
    const b = Buffer.allocUnsafe(5)
    buf.copy(b, 0, i);
    console.log(decoder.write(b))
}
  • path 模块
  • http 模块
  • fs 模块
  • url 模块
  • query string 模块
  • os 模块
  • stream 模块

 

event

  • EventEmitter

const EventEmitter = require('events')
class myEvent extends EventEmitter{

}
var index = 0;
const ce = new myEvent()

ce.on('test',()=>{
    console.log('this is a eventEmitter')
})

var timer = setInterval(()=>{
    if(index++>20){
        clearInterval(timer)
    }
    ce.emit('test')
},500)
  • once

const EventEmitter = require('events')
class myEvent extends EventEmitter{

}
var index = 0;
const ce = new myEvent()

ce.on('test',()=>{
    console.log('this is a eventEmitter')
})

var timer = setInterval(()=>{
    if(index++>20){
        clearInterval(timer)
    }
    ce.emit('test')
},500)
  • 三个参数

const EventEimtter = require('events')

class CustomEvent extends EventEimtter {
}

const ce = new CustomEvent()
ce.on('error', (err, time) => {
   console.log(err)
   console.log(time)
})

ce.emit('error', new Error('oppsliving'), Date.now())
  • remove

const EventEmitter = require('events')
class CustomEvent extends EventEmitter{}
const ce = new CustomEvent()
function fn1() {
    console.log('fn1')
}
function fn2() {
    console.log('fn2')
}
ce.on('test',fn1)
ce.on('test',fn2)

setInterval(()=>{
    ce.emit('test')
},500)

setTimeout(()=>{
    ce.removeListener('test',fn2)
},2500)

setTimeout(()=>{
    ce.removeAllListeners('test')
},1000)

转发请表明出处,多谢支持~

Node.js文件系统、路径的操作函数

fs

  • readFile、writeFile、readFileSync、unlink

const fs = require('fs')
fs.readFile('../buffer/decode.js', 'utf8', (err, data) => {
    if (err) throw err;
    console.log(data)
})
const content = Buffer.from('this is a test fs buffer')
fs.writeFile('./text.txt', content, {
    encoding: 'utf8'
}, err => {
    if (err) throw err
    console.log('done')
})

const data = fs.readFileSync('../event/once.js', 'utf8')
console.log(data + '\n\n\n')

//删除文件
fs.unlink('./text',err=>{
    if(err)throw err
})
  • stat、rename、readdir

const fs = require('fs')

fs.stat('../event/params.js',(err,stats)=>{
    if(err){
        console.log('文件不存在')
        return
    }
    console.log(stats.isFile())
    console.log(stats.isDirectory())

    console.log(stats)
})

fs.rename('./text.txt','test.md',err=>{
    if(err)throw err
    console.log('done!')
})

fs.readdir('./',(err,files)=>{
    if(err)throw err
    console.log(files)
})

fs.mkdir('test',err=>{
    if(flag<50)return
    fs.rmdir('test',err=>{})
})
  • watch、createReadStream、createWriteStream

const fs = require('fs')

fs.watch('./',{
    //递归
    recursive:true
},(eventType,filename)=>{
    console.log(eventType,filename)
})

//流:有方向的数据
const fs = require('fs')
const rs = fs.createReadStream('./readdir.js')

//process.stdout导出到控制台
rs.pipe(process.stdout)


const ws = fs.createWriteStream('./test.txt')

const tid = setInterval(()=>{
    const num = parseInt(Math.random()*10)
    console.log(num)
    if(num<8){
        ws.write(''+num)
    }else {
        clearInterval(tid)
        ws.end()
    }
},500)

ws.on('finish',()=>{
    console.log('done')
})
  • promisify化解地狱回调难点

const fs = require('fs')
const promisify = require('util').promisify

const read = promisify(fs.readFile)

read('./watch.js').then(data=>{
    console.log(data.toString())
}).catch(ex=>{
    console.log(ex)
})

async function test() {
    try {
        const content = await read('./watch.js')
        console.log(content.toString())
    }catch (ex){
        console.log(ex)
    }
}

test()

es陆语法封装promisify,它实在正是叁个promise对象

const fs = require('fs')
//模拟promisify
function Promisify(fn) {
    return function (...args) {
        return new Promise((resolve,reject)=>{
            fn(...args,(err,res)=>{
                if(err)return reject(err)
                resolve(res)
            })
        })
    }
}

const read = Promisify(fs.readFile)

read('test.txt').then(data=>{
    console.log(data.toString())
}).catch(err=>{
    console.log(err)
})

async function test() {
    try {
        const data = await read('./test.md')
        console.log(data.toString())
    }catch (ex){
        console.log(ex)
    }
}

test()

path 路径相关模块

目录

模块简介

nodejs path
模块提供了1些用来拍卖公事路径的工具函数,大家可以通过如下格局引用它

 var path = require("path")

Node.js文件系统、路径的操作函数… 壹

path.normalize(p)

条件路径字符串,处理冗余的“..”、“.”、“/”字符:

原则:

  • 对window系统,目录分隔为”,对于UNIX系统,分隔符为’/’,针对’..’再次回到上拔尖;/与\都被统一更换path.normalize(p);

  • 一旦路径为空,再次回到.,也正是方今的干活路线。

  • 将对路线中重复的路径分隔符(比如linux下的/)合并为二个。

  • 对路线中的.、..举行处理。(类似于shell里的cd ..)

  • 假设路径最终有/,那么保留该/。

    var url1 = path.normalize(‘a/b/c/../user/vajoy/bin’);
    var url2 = path.normalize(‘a/b/c///../user/vajoy/bin/’);
    var url3 = path.normalize(‘a/b/c/../../user/vajoy/bin’);
    var url4 = path.normalize(‘a/b/c/.././///../user/vajoy/bin/..’);
    var url5 = path.normalize(‘a/b/c/../../user/vajoy/bin/../../’);
    var url6 = path.normalize(‘a/../../user/vajoy/bin/../../’);
    var url7 = path.normalize(‘a/../../user/vajoy/bin/../../../../’);
    var url8 = path.normalize(‘./a/.././user/vajoy/bin/./’);

    console.log(‘url1:’,url1); // a\b\user\vajoy\bin
    console.log(‘url2:’,url2); // a\b\user\vajoy\bin
    console.log(‘url3:’,url3); // a\user\vajoy\bin
    console.log(‘url4:’,url4); // a\user\vajoy
    console.log(‘url5:’,url5); // a\user
    console.log(‘url6:’,url6); // ..\user
    console.log(‘url7:’,url7); // ….
    console.log(‘url8:’,url8); // user\vajoy\bin\

一、读取文件readFile函数… 一

path.join([path1], [path2], […])

将两个途径结合在1齐,并更换为条件的路线

var url1 = path.join('////./a', 'b////c', 'user/', 'vajoy', '..');
var url2 = path.join('a', '../../', 'user/', 'vajoy', '..');
var url3 = path.join('a', '../../', {}, 'vajoy', '..');
var url4 = path.join('path1', 'path2//pp\\', ../path3');

console.log('url1:',url1);  // \a\b\c\user
console.log('url2:',url2);  // ..\user
console.log('url3:',url3);  // 存在非路径字符串,故抛出异常
console.log('url4:',url4);  // path1\path2\path3

2、写文件… 1

path.resolve([from …], to)

从源地址 from 到指标地址 to 的相对路径

原则
以应用程序根目录为源点,依据参数字符串解析出3个相对路径
要留心的是,要是有些 from 或 to 参数是相对路径(比如
‘E:/abc’,或是以“/”开头的不贰秘籍),则将忽略在此以前的 from 参数。

// 下文中app的根目录为D:\temp\test
var url1 = path.resolve('.', 'testFiles/..', 'trdLayer');
var url2 = path.resolve('..', 'testFiles', 'a.txt');
var url3 = path.resolve('D:/vajoy', 'abc', 'D:/a');
var url4 = path.resolve('abc', 'vajoy', 'ok.gif');
var url5 = path.resolve('abc', '/vajoy', '..', 'a/../subfile'); //'abc'参数将被忽略,源路径改从'D:/vajoy'开始

console.log('url1:',url1);  //D:\temp\test\trdLayer
console.log('url2:',url2);  //D:\temp\testFiles\a.txt
console.log('url3:',url3);  //D:\a
console.log('url4:',url4);  //D:\temp\test\abc\vajoy\ok.gif
console.log('url5:',url5);  //D:\subfile

叁、以充实格局写文件… 三

path.relative(from, to)

获取从 from 到 to
的相对路径(即,基于from路径的两路径间的相互关系),能够用作 path.resolve
的相反实现

var url1 = path.relative('C:\\vajoy\\test\\aaa', 'C:\\vajoy\\impl\\bbb');
var url2 = path.relative('C:/vajoy/test/aaa', 'C:/vajoy/bbb');
var url3 = path.relative('C:/vajoy/test/aaa', 'D:/vajoy/bbb');

console.log('url1:',url1);  //..\..\impl\bbb
console.log('url2:',url2);  //..\..\bbb
console.log('url3:',url3);  //D:\vajoy\bbb
  • 1旦from、to指向同个路子,那么,重临空字符串。
  • 路线的操作详解,学习种类。只要from、to中任一者为空,那么,重返当前工作路径。

四、打开文件… 三

path.isAbsolute(path)

判定 path 是不是绝对路径。那块能够清楚为,path
是还是不是确实是贰个相对路径(比如
‘E:/abc’),或然是以“/”开始的门路,2者都会重临true

var url1 = path.isAbsolute('../testFiles/secLayer');
var url2 = path.isAbsolute('./join.js');
var url3 = path.isAbsolute('temp');
var url4 = path.isAbsolute('/temp/../..');
var url5 = path.isAbsolute('E:/github/nodeAPI/abc/efg');
var url6 = path.isAbsolute('///temp123');

console.log('url1:',url1);  // false
console.log('url2:',url2);  // false
console.log('url3:',url3);  // false
console.log('url4:',url4);  // true
console.log('url5:',url5);  // true
console.log('url6:',url6);  // true

5、读文件,读取打开的公文内容到缓冲区中;… 四

path.dirname(p)

归来路径中文件夹的门径

var url1 = path.dirname('/foo/bar/baz/asdf/a.txt');
var url2 = path.dirname('/foo/bar/baz/asdf/');
var url3 = path.dirname('C:/vajoy/test/aaa');
var url4 = path.dirname(__dirname + '/docs/a.txt')

console.log('url1:',url1);  // /foo/bar/baz/asdf
console.log('url2:',url2);  // /foo/bar/baz
console.log('url3:',url3);  // C:/vajoy/test
console.log(url4);// D:\mobileWeb\temp\test/docs

陆、写文件,将缓冲区内数据写入使用fs.open打开的文件… 5

path.basename(p, [ext])

回来路径中的最终一局地(常常为文件名),类似于Unix 的 basename 命令。
ext 为必要截掉的尾缀内容

var url1 = path.basename('/foo/bar/baz/asdf/a.txt');
var url2 = path.basename('/foo/bar/baz/asdf/a.txt','.txt');
var url3 = path.basename('/foo/bar/baz/asdf/');
var url4 = path.basename('C:/vajoy/test/aaa');

console.log('url1:',url1);  // a.txt
console.log('url2:',url2);  // a
console.log('url3:',url3);  // asdf
console.log('url4:',url4);  // aaa

7、刷新缓存区;陆

path.extname(p)

回去路径文件中的扩展名(若存在)

var url1 = path.extname('/foo/bar/baz/asdf/a.txt');
var url2 = path.extname('/foo/bar/baz/asdf/a.txt.html');
var url3 = path.extname('/foo/bar/baz/asdf/a.');
var url4 = path.extname('C:/vajoy/test/.');
var url5 = path.extname('C:/vajoy/test/a');

console.log('url1:',url1);  // .txt
console.log('url2:',url2);  // .html
console.log('url3:',url3);  // .
console.log('url4:',url4);  //
console.log('url5:',url5);  //

8、成立目录;柒

path.parse(pathString)

回来路径字符串的对象

var url1 = path.parse('/foo/bar/baz/asdf/a.txt');
url1: { 
  root: '/',//根目录  
  dir: '/foo/bar/baz/asdf',//文件所在目录 
  base: 'a.txt',//文件名,输出文件名称以base为准,base为空,则不输出文件名 
  ext: '.txt',//文件扩展名
  name: 'a',//文件名称, 不含扩展名(name返回的是文件名或最后文件夹名)
}

var url2=path.parse('C:\\path\\dir\\');  
{ root: 'C:\\',  
  dir: 'C:\\path',  
  base: 'dir',  
  ext: '',  
  name: 'dir'   
} 

var url3=path.format({  
    root:'f:',  
    dir:'f:\\dir1\\dir2',  
    name:'file', 
    base:'file.nanme', 
    ext:'.txt'  
}); 
//f:\dir1\dir2\file.nanme

var url3=path.format({  
    root:'f:',  
    dir:'f:\\dir1\\dir2',  
    name:'file', 
    ext:'.txt'  
}); 
//f:\dir1\dir2\

九、读取目录;7

path.format(pathObject)

从目的中回到路径字符串,和 path.parse 相反

var pathObj =  { 
      root: '/',
      dir: '/foo/bar/baz/asdf',
      base: 'a.txt',
      ext: '.txt',
      name: 'a' 
}

var url1 = path.format(pathObj);
console.log('url1:',url1);//url1: /foo/bar/baz/asdf\a.txt

10、查看文件与目录的音讯;八

path.sep

*归来对应平台下的文本夹分隔符,win下为”,nix下为’/’\

var url1 = path.sep;
var url2 = 'foo\\bar\\baz'.split(path.sep);
var url3 = 'foo/bar/baz'.split(path.sep);

console.log('url1:',url1);  // win下为\,*nix下为/
console.log('url2:',url2);  // [ 'foo', 'bar', 'baz' ]?
console.log('url3:',url3);  // win下返回[ 'foo/bar/baz' ],但在*nix系统下会返回[ 'foo', 'bar', 'baz' ]

1一、查看文件与目录的是或不是留存… 玖

path.delimiter

*归来对应平台下的不二秘诀分隔符,win下为’;’,nix下为’:’\

var env = process.env.PATH; //当前系统的环境变量PATH

var url1 = env.split(path.delimiter);

console.log(path.delimiter); 
//win下为“;”,*nix下为“:”
console.log('env:',env); 
// C:\ProgramData\Oracle\Java\javapath;C:\Program Files (x86)\Intel\iCLS Client\;
console.log('url1:',url1);  
// ['C:\ProgramData\Oracle\Java\javapath','C:\Program Files (x86)\Intel\iCLS Client\']

1二、修改文件访问时间与修改时间… 九

http 网络请求模块

壹三、修改文件或目录的操作权限… 十

引入小说

  • nodejs 多少个常用 http 模块

1四、移动/重命名文件或目录… 拾

fs 文件系统操作模块

一五、删除空目录… 1一

模块简介

nodejs path
模块提供了有些用于拍卖文件系统的小工具,大家能够通过如下格局引用它

 var path = require("fs")

16、监视文件… 1一

同步&&异步API

使用require('fs')载入fs模块,模块中颇具办法都有1块和异步几种样式。

异步方法中回调函数的率先个参数总是留给格外参数(exception),假诺格局成功实现,该参数为null或undefined。

fs.readFile('./test.txt', function(err, data) {
    if (err) throw err;
    console.log('文件内容:'+ data);
});

一路写法,一般皆以在异步方法名后拼接Sycn字符串,表示是一块方法

var data = fs.readFileSync('./test.txt');
console.log('文件内容:'+ data);

手拉手方法执行完并回到结果后,才能进行后续的代码。而异步方法运用回调函数接收再次来到结果,可以立时实施后续代码。上面包车型大巴代码演示,都已异步逻辑为主。

一七、裁撤监视文件… 1二

fs.readFile

/**
 * filename, 必选参数,文件名
 * [options],可选参数,可指定flag(文件操作选项,如r+ 读写;w+ 读写,文件不存在则创建)及encoding属性
 * callback 读取文件后的回调函数,参数默认第一个err,第二个data 数据
 */

fs.readFile(__dirname + '/test.txt', {flag: 'r+', encoding: 'utf8'}, function (err, data) {
    if(err) throw err;
    console.log(data);
});

18、文件流… 13

fs.writeFile

var w_data = '这是一段通过fs.writeFile函数写入的内容;\r\n';
//w_data = new Buffer(w_data);//可以将字符串转换成Buffer类型

/**
 * filename, 必选参数,文件名
 * data, 写入的数据,可以字符或一个Buffer对象
 * [options],flag,mode(权限),encoding
 * callback 读取文件后的回调函数,参数默认第一个err,第二个data 数据
 */

fs.writeFile(__dirname + '/test.txt', w_data, {flag: 'a'}, function (err) {

    if(err) throw err;
    console.log('写入成功');

});

{flag: 'a'}
加上那几个参数,内容将会被以追加格局写入文件,不丰硕这么些参数则会先清空内容,再写入数据

1九、创立读取流… 一伍

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

/**
 * filename, 必选参数,文件名
 * flags, 操作标识,如"r",读方式打开
 * [mode],权限,如777,表示任何用户读写可执行
 * callback 打开文件后回调函数,参数默认第一个err,第二个fd为一个整数,表示打开文件返回的文件描述符,window中又称文件句柄
 */

fs.open(__dirname + '/test.txt', 'r', '0666', function (err, fd) {
  console.log(fd);
});

20、创造写入流… 1陆

fs.read(fd, buffer, offset, length, position, callback);

讲文件内容读入缓存区
/**
* fd, 使用fs.open打开成功后重临的公文讲述符
* buffer, 二个Buffer对象,v8引擎分配的一段内部存款和储蓄器
* offset, 整数,向缓存区中写入时的上马地方,以字节为单位
* length, 整数,读取文件的长度
* position, 整数,读取文件开端地点;文件大小以字节为单位
* callback(err, bytesRead, buffer),
读取执行到位后回调函数,bytesRead实际读取字节数,被读取的缓存区对象
*/

fs.open(__dirname + '/test.txt', 'r', function (err, fd) {
  if(err) {
    console.error(err);
    return;
  } else {
    var buffer = new Buffer(255);
    console.log(buffer.length);
    //每一个汉字utf8编码是3个字节,英文是1个字节
    fs.read(fd, buffer, 0, 9, 3, function (err, bytesRead, buffer) {
      if(err) {
        throw err;
      } else {
        console.log(bytesRead);
        console.log(buffer.slice(0, bytesRead).toString());
        //读取完后,再使用fd读取时,基点是基于上次读取位置计算;
        fs.read(fd, buffer, 0, 9, null, function (err, bytesRead, buffer) {
          console.log(bytesRead);
          console.log(buffer.slice(0, bytesRead).toString());
        });
      }
    });
  }
});

二1、管道pipe达成流读写… 1八

fs.write(fd, buffer, offset, length, position, callback);

写文件,将缓冲区内数据写入使用fs.open打开的公文

/**
 * fd, 使用fs.open打开成功后返回的文件描述符
 * buffer, 一个Buffer对象,v8引擎分配的一段内存
 * offset, 整数,从缓存区中读取时的初始位置,以字节为单位
 * length, 整数,从缓存区中读取数据的字节数
 * position, 整数,写入文件初始位置;
 * callback(err, written, buffer), 写入操作执行完成后回调函数,written实际写入字节数,buffer被读取的缓存区对象
 */

fs.open(__dirname + '/test.txt', 'a', function (err, fd) {
  if(err) {
    console.error(err);
    return;
  } else {
    var buffer = new Buffer('写入文件数据内容');
    //写入'入文件'三个字
    fs.write(fd, buffer, 3, 9, 12, function (err, written, buffer) {
      if(err) {
        console.log('写入文件失败');
        console.error(err);
        return;
      } else {
        console.log(buffer.toString());
        //写入'数据内'三个字
        fs.write(fd, buffer, 12, 9, null, function (err, written, buffer) {
          console.log(buffer.toString());
          // 使用fs.write写入文件时,操作系统是将数据读到内存,再把数据写入到文件中,所以当数据读完时并不代表数据已经写完,因为有一部分还可能在内在缓冲区内。
          // 因此可以使用fs.fsync方法将内存中数据写入文件,刷新内存缓冲区;
          fs.fsync(fd);
          fs.close(fd);
        })
      }
    });
  }
});

2二、路径解析,得到规范化的门径格式… 1九

fs.mkdir(path, [mode], callback)

始建目录

/**
 * path, 被创建目录的完整路径及目录名;
 * [mode], 目录权限,默认0777
 * [callback(err)], 创建完目录回调函数,err错误对象
 */

fs.mkdir(__dirname + '/fsDir', function (err) {
  if(err)
    throw err;
  console.log('创建目录成功')
});

二三、路径结合、合并,路径最终不会带目录分隔符… 1九

fs.readdir(path, callback)

读取目录

/**
 * path, 要读取目录的完整路径及目录名;
 * [callback(err, files)], 读完目录回调函数;err错误对象,files数组,存放读取到的目录中的所有文件名
 */

fs.readdir(__dirname + '/fsDir/', function (err, files) {
  if(err) {
    console.error(err);
    return;
  } else {
    files.forEach(function (file) {
      var filePath = path.normalize(__dirname + '/fsDir/' + file);
      fs.stat(filePath, function (err, stat) {
        if(stat.isFile()) {
          console.log(filePath + ' is: ' + 'file');
        }
        if(stat.isDirectory()) {
          console.log(filePath + ' is: ' + 'dir');
        }
      });
    });
  }
});

2肆、获取相对路径… 20

fs.stat(path, callback);

翻看文件与目录消息

fs.stat(__dirname + '/test.txt', function (err, stat) {
    console.log('访问时间: ' + stat.atime.toString() + '; \n修改时间:' + stat.mtime);
    console.log(stat.mode);
  })

二伍、获取相对路径… 20

fs.exists(path, callback);

翻开文件与目录是还是不是留存

/**
 * path, 要查看目录/文件的完整路径及名;
 * [callback(exists)], 操作完成回调函数;exists true存在,false表示不存在
 */

fs.exists(__dirname + '/test', function (exists) {
  var retTxt = exists ? retTxt = '文件存在' : '文件不存在';
  console.log(retTxt);
});

26、path.dirname(p). 20

fs.rename(oldPath, newPath, callback);

活动/重命名文件或目录

/**
 * oldPath, 原目录/文件的完整路径及名;
 * newPath, 新目录/文件的完整路径及名;如果新路径与原路径相同,而只文件名不同,则是重命名
 * [callback(err)], 操作完成回调函数;err操作失败对象
 */
fs.rename(__dirname + '/test', __dirname + '/fsDir', function (err) {
  if(err) {
    console.error(err);
    return;
  }
  console.log('重命名成功')
});

27、path.basename(path,
[ext]). 21

fs.rmdir(path, callback);

删除空目录

/**
 * path, 目录的完整路径及目录名;
 * [callback(err)], 操作完成回调函数;err操作失败对象
 */
fs.mkdir(__dirname + '/test', function(err){
    fs.rmdir(__dirname + '/test', function (err) {
      if(err) {
        console.log('删除空目录失败,可能原因:1、目录不存在,2、目录不为空')
        console.error(err);
        return;
      }
      console.log('删除空目录成功!');
    });
}) 

28、path.extname(path). 21

fs.watchFile(filename, [options], listener);

对文件举行监视,并且在监视到文件被改动时实施处理

/**
 * filename, 完整路径及文件名;
 * [options], persistent true表示持续监视,不退出程序;interval 单位毫秒,表示每隔多少毫秒监视一次文件
 * listener, 文件发生变化时回调,有两个参数:curr为一个fs.Stat对象,被修改后文件,prev,一个fs.Stat对象,表示修改前对象
 */
fs.watchFile(__dirname + '/test.txt', {interval: 20}, function (curr, prev) {
  if(Date.parse(prev.ctime) == 0) {
    console.log('文件被创建!');//?
  } else if(Date.parse(curr.ctime) == 0) {
    console.log('文件被删除!')
  } else if(Date.parse(curr.mtime) != Date.parse(prev.mtime)) {
    console.log('文件有修改');
  }
});
fs.watchFile(__dirname + '/test.txt', function (curr, prev) {
  console.log('这是第二个watch,监视到文件有修改');
});

29、path.sep 属性… 21

fs.watch(filename, [options], [listener]);

对文本或目录进行监视,并且在监视到修改时实施处理;
fs.watch重临1个fs.FS沃特cher对象,拥有二个close方法,用于结束watch操作;
当fs.watch有文件变化时,会触发fs.FS沃特cher对象的change(err,
filename)事件,err错误对象,filename发生变化的文书名

/**
 * filename, 完整路径及文件名或目录名;
 * [listener(event, filename], 监听器事件,有两个参数:event 为rename表示指定的文件或目录中有重命名、删除或移动操作或change表示有修改,filename表示发生变化的文件路径
 */

var fsWatcher = fs.watch(__dirname + '/test', function (event, filename) {
  //console.log(event)
});

//console.log(fsWatcher instanceof FSWatcher);

fsWatcher.on('change', function (event, filename) {
  console.log(filename + ' 发生变化')
});

//30秒后关闭监视
setTimeout(function () {
  console.log('关闭')
  fsWatcher.close(function (err) {
    if(err) {
      console.error(err)
    }
    console.log('关闭watch')
  });
}, 30000);    

30、path.delimiter属性… 21

文件流

 /*
 * 流,在应用程序中表示一组有序的、有起点有终点的字节数据的传输手段;
 * Node.js中实现了stream.Readable/stream.Writeable接口的对象进行流数据读写;以上接口都继承自EventEmitter类,因此在读/写流不同状态时,触发不同事件;
 * 关于流读取:Node.js不断将文件一小块内容读入缓冲区,再从缓冲区中读取内容;
 * 关于流写入:Node.js不断将流数据写入内在缓冲区,待缓冲区满后再将缓冲区写入到文件中;重复上面操作直到要写入内容写写完;
 * readFile、read、writeFile、write都是将整个文件放入内存而再操作,而则是文件一部分数据一部分数据操作;
 *
 * -----------------------流读取-------------------------------------
 * 读取数据对象:
 * fs.ReadStream 读取文件
 * http.IncomingMessage 客户端请求或服务器端响应
 * net.Socket    Socket端口对象
 * child.stdout  子进程标准输出
 * child.stdin   子进程标准入
 * process.stdin 用于创建进程标准输入流
 * Gzip、Deflate、DeflateRaw   数据压缩
 *
 * 触发事件:
 * readable  数据可读时
 * data      数据读取后
 * end       数据读取完成时
 * error     数据读取错误时
 * close     关闭流对象时
 *
 * 读取数据的对象操作方法:
 * read      读取数据方法
 * setEncoding   设置读取数据的编
 * pause     通知对象众目停止触发data事件
 * resume    通知对象恢复触发data事件
 * pipe      设置数据通道,将读入流数据接入写入流;
 * unpipe    取消通道
 * unshift   当流数据绑定一个解析器时,此方法取消解析器
 *
 * ------------------------流写入-------------------------------------
 * 写数据对象:
 * fs.WriteStream           写入文件对象
 * http.clientRequest       写入HTTP客户端请求数据
 * http.ServerResponse      写入HTTP服务器端响应数据
 * net.Socket               读写TCP流或UNIX流,需要connection事件传递给用户
 * child.stdout             子进程标准输出
 * child.stdin              子进程标准入
 * Gzip、Deflate、DeflateRaw  数据压缩
 *
 * 写入数据触发事件:
 * drain            当write方法返回false时,表示缓存区中已经输出到目标对象中,可以继续写入数据到缓存区
 * finish           当end方法调用,全部数据写入完成
 * pipe             当用于读取数据的对象的pipe方法被调用时
 * unpipe           当unpipe方法被调用
 * error            当发生错误
 *
 * 写入数据方法:
 * write            用于写入数据
 * end              结束写入,之后再写入会报错;
 */

参考:… 21

fs.createReadStream(path, [options])

成立读取流

/**
 * path 文件路径
 * [options] flags:指定文件操作,默认'r',读操作;encoding,指定读取流编码;autoClose, 是否读取完成后自动关闭,默认true;start指定文件开始读取位置;end指定文件开始读结束位置
 */

var rs = fs.createReadStream(__dirname + '/test.txt', {start: 0, end: 2});
  //open是ReadStream对象中表示文件打开时事件,
rs.on('open', function (fd) {
  console.log('开始读取文件');
});

rs.on('data', function (data) {
  console.log(data.toString());
});

rs.on('end', function () {
  console.log('读取文件结束')
});
rs.on('close', function () {
  console.log('文件关闭');
});

rs.on('error', function (err) {
  console.error(err);
});

//暂停和回复文件读取;
rs.on('open', function () {
  console.log('开始读取文件');
});

rs.pause();

rs.on('data', function (data) {
  console.log(data.toString());
});

setTimeout(function () {
  rs.resume();
}, 2000);

 

fs.createWriteStream(path, [options])

创立写入流

/**
 * path 文件路径
 * [options] flags:指定文件操作,默认'w',;encoding,指定读取流编码;start指定写入文件的位置
 */

/* ws.write(chunk, [encoding], [callback]);
 * chunk,  可以为Buffer对象或一个字符串,要写入的数据
 * [encoding],  编码
 * [callback],  写入后回调
 */

/* ws.end([chunk], [encoding], [callback]);
 * [chunk],  要写入的数据
 * [encoding],  编码
 * [callback],  写入后回调
 */

var ws = fs.createWriteStream(__dirname + '/test.txt', {start: 0});
var buffer = new Buffer('我也喜欢你');
ws.write(buffer, 'utf8', function (err, buffer) {
  console.log(arguments);
  console.log('写入完成,回调函数没有参数')
});
//最后再写入的内容
ws.end('再见');
//使用流完成复制文件操作
var rs = fs.createReadStream(__dirname + '/test.txt')
var ws = fs.createWriteStream(__dirname + '/test/test.txt');

rs.on('data', function (data) {
  ws.write(data)
});

ws.on('open', function (fd) {
  console.log('要写入的数据文件已经打开,文件描述符是: ' + fd);
});

rs.on('end', function () {
  console.log('文件读取完成');
  ws.end('完成', function () {
    console.log('文件全部写入完成')
  });
});


//关于WriteStream对象的write方法返回一个布尔类型,当缓存区中数据全部写满时,返回false;
//表示缓存区写满,并将立即输出到目标对象中

//第一个例子
var ws = fs.createWriteStream(__dirname + '/test/test.txt');
for (var i = 0; i < 10000; i++) {
  var w_flag = ws.write(i.toString());
  //当缓存区写满时,输出false
  console.log(w_flag);
}


//第二个例子
var ws = fs.createWriteStream(__dirname + '/test/untiyou.mp3');
var rs = fs.createReadStream(__dirname + '/test/Until You.mp3');
rs.on('data', function (data) {
  var flag = ws.write(data);
  console.log(flag);
});

//系统缓存区数据已经全部输出触发drain事件
ws.on('drain', function () {
  console.log('系统缓存区数据已经全部输出。')
});

 

rs.pipe(destination, [options]);

管道pipe完成流读写

//rs.pipe(destination, [options]);
/**
 * destination 必须一个可写入流数据对象
 * [opations] end 默认为true,表示读取完成立即关闭文件;
 */

var rs = fs.createReadStream(__dirname + '/test/Until You.mp3');
var ws = fs.createWriteStream(__dirname + '/test/untiyou.mp3');
rs.pipe(ws);
rs.on('data', function (data) {
  console.log('数据可读')
});
rs.on('end', function () {
  console.log('文件读取完成');
  //ws.end('再见')
});

将Node.js的文件系统、文件流及路径操作API详细的求学了眨眼间间,代码都是测试过的,可能一点也不细略,但为了打好基础,如故要有点战战兢兢的振奋,从中作者也更深入领会异步回调事件机制,希望对你有用……

引入小说

fs模块实例参考

//公共引用

url 处理模块

1.       
var fs =
require(‘fs’),

引用

var url = require("url");

2.       
    path = require(‘path’);

URL 的组合介绍

对此3个 U路虎极光L
字符串,其组成部分会有全数分化,在那之中有个别部分只有在URL字符串中存在时,对应字段才会油不过生在条分缕析后对象中。以下是二个UPAJEROL 例子:

http://user:pass@host.com:8080/p/a/t/h?query=string#hash

href: 解析前的完整原始 URL,协议名和主机名已转为小写
例如: 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash'

protocol: 请求协议,小写
例如: 'http:'

slashes: 协议的“:”号后是否有“/”
例如: true or false

auth: URL中的认证信息
例如: 'user:pass'

host: URL主机名,包括端口信息,小写
例如: 'host.com:8080'

hostname: 主机名,小写
例如: 'host.com'

port: 主机的端口号
例如: '8080'

path: pathname 和 search的合集
例如: '/p/a/t/h?query=string'

pathname: URL中路径
例如: '/p/a/t/h'

search: 查询对象,即:queryString,包括之前的问号“?”
例如: '?query=string'

query: 查询字符串中的参数部分(问号后面部分字符串),或者使用 querystring.parse() 解析后返回的对象
例如: 'query=string' or {'query':'string'}

hash: 锚点部分(即:“#”及其后的部分)
例如: '#hash'

壹、读取文件readFile函数

//readFile(filename,[options],callback);

/**

 * filename,
必选参数,文件名

 *
[options],可选参数,可钦赐flag(文件操作选项,如r+ 读写;w+ 读写,文件不设有则创建)及encoding属性

 * callback
读取文件后的回调函数,参数暗中同意第二个err,第3个data 数据

 */

1.       
fs.readFile(__dirname + ‘/test.txt’, {flag: ‘r+’, encoding:
‘utf8’}, function (err, data) {

2.       
    if(err) {

3.       
        console.error(err);

4.       
        return;

5.       
    }

6.       
    console.log(data);

7.       
});

url.parse(urlStr[, parseQueryString][, slashesDenoteHost])

将U翼虎L字符串转换为JSON对象

var urlString = 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash';
var result = url.parse(urlString);
console.log(result);

//输出结果如下
{ protocol: 'http:',
  slashes: true,
  auth: 'user:pass',
  host: 'host.com:8080',
  port: '8080',
  hostname: 'host.com',
  hash: '#hash',
  search: '?query=string',
  query: 'query=string',
  pathname: '/p/a/t/h',
  path: '/p/a/t/h?query=string',
  href: 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash' 
}

//第二个可选参数设置为true时,会使用querystring模块来解析URL中德查询字符串部分,默认为 false。
var result1 = url.parse(urlString, true);
console.log(result1);
//输出结果如下
{ protocol: 'http:',
  slashes: true,
  auth: 'user:pass',
  host: 'host.com:8080',
  port: '8080',
  hostname: 'host.com',
  hash: '#hash',
  search: '?query=string',
  query: {query:"string"},
  pathname: '/p/a/t/h',
  path: '/p/a/t/h?query=string',
  href: 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash' 
}

2、写文件

// fs.writeFile(filename,data,[options],callback);

var w_data = ‘那是1段通过fs.writeFile函数写入的内容;\r\n’;

var w_data = new Buffer(w_data);

 

/**

 * filename,
必选参数,文件名

 * data,
写入的数目,能够字符或二个Buffer对象

 *
[options],flag,mode(权限),encoding

 * callback
读取文件后的回调函数,参数暗许第一个err,第二个data 数据

 */

1.       
fs.writeFile(__dirname + ‘/test.txt’, w_data, {flag: ‘a’}, function (err) {

2.       
    if(err) {

3.       
        console.error(err);

4.       
    } else {

5.       
        console.log(‘写入成功’);

6.       
    }

7.       
});

 

url.format(urlObj)

用以格式化U奥迪Q5L对象。输入二个 U猎豹CS陆L 对象,再次来到格式化后的 U猎豹CS陆L
字符串。示例如下

var urlObj = { 
  protocol: 'http:',
    slashes: true,
    hostname: 'jianshu.com',
    port: 80,
    hash: '#hash',
    search: '?query=string',
    path: '/nodejs?query=string'
}
var result = url.format(urlObj);
console.log(result);
//输出结果如下
http://jianshu.com:80?query=string#hash
/*
*传入的URL对象会做以下处理:
*
*href 属性会被忽略
*protocol无论是否有末尾的 : (冒号),会同样的处理
**这些协议包括 http, https, ftp, gopher, file 后缀是 :// (冒号-斜杠-斜杠).
**所有其他的协议如 mailto, xmpp, aim, sftp, foo, 等 会加上后缀 : (冒号)
*auth 如果有将会出现.
*host 优先使用,将会替代 hostname 和port
*hostname 如果 host 属性没被定义,则会使用此属性.
*port 如果 host 属性没被定义,则会使用此属性.
*pathname 将会同样处理无论结尾是否有/ (斜杠)
*search 将会替代 query属性
*query (object类型; 详细请看 querystring) 如果没有 search,将会使用此属性.
*search 无论前面是否有 ? (问号),都会同样的处理
*hash无论前面是否有# (井号, 锚点),都会同样处理
*/

三、以追加情势写文件

// fs.appendFile(filename,data,[options],callback);

1.       
fs.appendFile(__dirname + ‘/test.txt’, ‘使用fs.appendFile追加文件内容’, function () {

2.       
    console.log(‘追加内容实现’);

3.       
});

 

url.resolve(from, to)

用于拼接路径

url.resolve('/one/two/three', 'four')         // '/one/two/four'
url.resolve('http://example.com/', '/one')    // 'http://example.com/one'
url.resolve('http://example.com/one', '/two') // 'http://example.com/two'

肆、打开文件

// fs.open(filename,
flags, [mode], callback);

/**

 * filename,
必选参数,文件名

 * flags,
操作标识,如”r”,读格局打开

 *
[mode],权限,如777,表示其他用户读写可进行

 * callback
打开文件后回调函数,参数暗许第3个err,第二个fd为二个整数,表示打开文件再次来到的公文描述符,window中又称文件句柄

 */

1.       
fs.open(__dirname + ‘/test.txt’, ‘r’, ‘0666’, function (err, fd) {

2.       
    console.log(fd);

3.       
});

 

query string 参数处理模块

五、读文件,读取打开的文件内容到缓冲区中;

// fs.read(fd, buffer, offset, length, position,
callback);

/**

 * fd, 使用fs.open打开成功后归来的公文讲述符

 * buffer,
贰个Buffer对象,v捌引擎分配的壹段内存

 * offset,
整数,向缓存区中写入时的起始地点,以字节为单位

 * length,
整数,读取文件的尺寸

 * position,
整数,读取文件初始地方;文件大小以字节为单位

 *
callback(err, bytesRead, buffer),
读取执行到位后回调函数,bytesRead实际读取字节数,被读取的缓存区对象

 */

 

1.       
fs.open(__dirname + ‘/test.txt’, ‘r’, function (err, fd) {

2.       
    if(err) {

3.       
        console.error(err);

4.       
        return;

5.       
    } else {

6.       
        var buffer = new Buffer(255);

7.       
        console.log(buffer.length);

八.       
        //每三个汉字utf八编码是一个字节,英文是二个字节

9.       
        fs.read(fd, buffer, 0, 9, 3, function (err, bytesRead, buffer) {

10.                 if(err)
{

11.                     throw
err;

12.                 }
else {

13.                     console.log(bytesRead);

14.                     console.log(buffer.slice(0, bytesRead).toString());

一5.                     //读取完后,再使用fd读取时,基点是依据上次读取地方计算;

16.                     fs.read(fd, buffer, 0, 9, null, function (err, bytesRead, buffer) {

17.                         console.log(bytesRead);

18.                         console.log(buffer.slice(0, bytesRead).toString());

19.                     });

20.                 }

21.             });

22.         }

23.     });

 

引用

var querystring = require('querystring')

陆、写文件,将缓冲区内数据写入使用fs.open打开的文本

//fs.write(fd, buffer, offset, length, position,
callback);

/**

 * fd, 使用fs.open打开成功后归来的文书讲述符

 * buffer,
二个Buffer对象,v捌引擎分配的1段内部存款和储蓄器

 * offset,
整数,从缓存区中读取时的初阶地点,以字节为单位

 * length,
整数,从缓存区中读取数据的字节数

 * position,
整数,写入文件初叶地方;

 *
callback(err, written, buffer), 写入操作实践到位后回调函数,written实际写入字节数,buffer被读取的缓存区对象

 */

 

1.       
fs.open(__dirname + ‘/test.txt’, ‘a’, function (err, fd) {

2.       
    if(err) {

3.       
        console.error(err);

4.       
        return;

5.       
    } else {

陆.       
        var buffer = new Buffer(‘写入文件数量内容’);

7.       
        //写入’入文件’三个字

8.       
        fs.write(fd, buffer, 3, 9, 12, function (err, written, buffer) {

9.       
            if(err)
{

十.                     console.log(‘写入文件失利’);

11.                     console.error(err);

12.                     return;

13.                 }
else {

14.                     console.log(buffer.toString());

15.                     fs.write(fd, buffer, 12, 9, null, function (err, written, buffer) {

16.                         console.log(buffer.toString());

17.                     })

18.                 }

19.             });

20.         }

21.     });

 

querystring.stringify(obj, [sep], [eq])

对象格式化成参数字符串 ,obj就是要格式化的指标,必选参数;[sep]指分隔符
暗中认可’&’; [eq]指分配符 暗中同意’=’

var querystring = require('querystring')
var param = {name:"feng",age:"33"};

var paramStr1 = querystring.stringify(param);
console.log(paramStr1);//name=feng&age=33
var paramStr2 = querystring.stringify(param,'$','-');
console.log(paramStr2);//name-feng$age-33

本方法会自动编码汉字

七、刷新缓存区;

// 使用fs.write写入文件时,操作系统是将数据读到内部存款和储蓄器,再把多少写入到文件中,当数码读完时并不代表数量已经写完,因为有一部分还可能在内在缓冲区内。

// 由此能够利用fs.fsync方法将内部存款和储蓄器中数据写入文件;–刷新内部存款和储蓄器缓冲区;

//fs.fsync(fd, [callback])

/**

 * fd, 使用fs.open打开成功后赶回的文本讲述符

 *
[callback(err, written, buffer)], 写入操作实践到位后回调函数,written实际写入字节数,buffer被读取的缓存区对象

 */

1.       
fs.open(__dirname + ‘/test.txt’, ‘a’, function (err, fd) {

2.       
    if(err)

3.       
        throw err;

4.       
    var buffer = new Buffer(‘我爱nodejs编程’);

5.       
 

6.       
    fs.write(fd, buffer, 0, 9, 0, function (err, written, buffer) {

7.       
        console.log(written.toString());

8.       
        fs.write(fd, buffer, 9, buffer.length – 9, null, function (err, written) {

9.       
            console.log(written.toString());

10.                 fs.fsync(fd);

11.                 fs.close(fd);

12.             })

13.         });

14.     });

 

querystring.parse(str, [sep], [eq], [options])

参数字符串格式化成对象

var paramStr1 = 'name=feng&age=33';
var paramStr2 = 'name-feng$age-33';

var param1 = querystring.parse(paramStr1);
console.log(param1);//{ name: 'feng', age: '33' }

var param2 = querystring.parse(paramStr2, '$', '-');
console.log(param2);//{ name: 'feng', age: '33' }

八、创立目录;

//使用fs.mkdir创立目录

//fs.mkdir(path,
[mode], callback);

/**

 * path,
被创设目录的全部路径及目录名;

 * [mode],
目录权限,暗中认可0777

 *
[callback(err)], 创立完目录回调函数,err错误对象

 */

1.       
fs.mkdir(__dirname + ‘/fsDir’,
function (err) {

2.       
    if(err)

3.       
        throw err;

4.       
 

伍.       
    console.log(‘成立目录成功’)

6.       
});

 

querystring.escape

参数编码

var param = "name=阿峰&age=33";

console.log(querystring.escape(param));
//name%3D%E9%98%BF%E5%B3%B0%26age%3D33

玖、读取目录;

//使用fs.readdir读取目录,重点其回调函数中files对象

//fs.readdir(path,
callback);

/**

 * path,
要读取目录的总体路径及目录名;

 *
[callback(err, files)], 读完目录回调函数;err错误对象,files数组,存放读取到的目录中的全体文件名

 */

1.       
fs.readdir(__dirname + ‘/fsDir/’,
function (err, files) {

2.       
    if(err) {

3.       
        console.error(err);

4.       
        return;

5.       
    } else {

6.       
        files.forEach(function (file) {

7.       
            var filePath = path.normalize(__dirname + ‘/fsDir/’ +
file);

8.       
            fs.stat(filePath, function (err, stat) {

9.       
                if(stat.isFile()) {

10.                         console.log(filePath + ‘ is: ‘ + ‘file’);

11.                     }

12.                     if(stat.isDirectory()) {

13.                         console.log(filePath + ‘ is: ‘ + ‘dir’);

14.                     }

15.                 });

16.             });

17.             for (var i =
0; i < files.length; i++) {

1捌.                 //使用闭包不能够担保读取文件的次第与数组中保留的致

19.                 (function ()
{

20.                     var filePath = path.normalize(__dirname + ‘/fsDir/’ +
files[i]);

21.                     fs.stat(filePath, function (err, stat) {

22.                         if(stat.isFile()) {

23.                             console.log(filePath + ‘ is: ‘ + ‘file’);

24.                         }

25.                         if(stat.isDirectory()) {

26.                             console.log(filePath + ‘ is: ‘ + ‘dir’);

27.                         }

28.                     });

29.                 })();

30.             }

31.         }

32.     });

 

querystring.unescape

参数解码

var param = "name=阿峰&age=33";

console.log(querystring.unescape(querystring.escape(param)));
//name=阿峰&age=33

十、查看文件与目录的音信;

//fs.stat(path,
callback);

//fs.lstat(path,
callback); //查看符号链接文件

/**

 * path,
要查看目录/文件的完整路径及名;

 *
[callback(err, stats)], 操作达成回调函数;err错误对象,stat fs.Stat2个对象实例,提供如:isFile, isDirectory,isBlockDevice等艺术及size,ctime,mtime等品质

 */

//实例,查看fs.readdir

 

os

1一、查看文件与目录的是否存在

//fs.exists(path,
callback);

/**

 * path,
要查阅目录/文件的全体路径及名;

 *
[callback(exists)], 操作完毕回调函数;exists true存在,false表示不设有

 */

1.       
fs.exists(__dirname + ‘/te’, function (exists) {

二.       
    var retTxt = exists ? retTxt = ‘文件存在’ :
‘文件不存在’;

3.       
    console.log(retTxt);

4.       
});

 

引用

var os = require('os');

1贰、修改文件访问时间与修改时间

//fs.utimes(path,
atime, mtime,
callback);

/**

 * path,
要翻看目录/文件的完全路径及名;

 * atime, 新的造访时间

 * ctime, 新的修改时间

 *
[callback(err)], 操作实现回调函数;err操作退步对象

 */

 

1.       
fs.utimes(__dirname + ‘/test.txt’, new Date(), new Date(), function (err) {

2.       
    if(err) {

3.       
        console.error(err);

4.       
        return;

5.       
    }

6.       
    fs.stat(__dirname + ‘/test.txt’, function (err, stat) {

七.       
        console.log(‘访问时间: ‘ + stat.atime.toString() + ‘; \n修改时间:’ + stat.mtime);

8.       
        console.log(stat.mode);

9.       
    })

10.     });

 

常用函数

//cpu架构
os.arch();

//操作系统内核
os.type();

//操作系统平台
os.platform();

//系统开机时间
os.uptime();

//主机名
os.hostname();

//主目录
os.homedir();


//内存
os.totalmem();//总内存
os.freemem();// 空闲内存

//cpu
const cpus = os.cpus();
cpus.forEach((cpu,idx,arr)=>{
    var times = cpu.times;
    console.log(`cpu${idx}:`);
    console.log(`型号:${cpu.model}`);
    console.log(`频率:${cpu.speed}MHz`);
    console.log(`使用率:${((1-times.idle/(times.idle+times.user+times.nice+times.sys+times.irq))*100).toFixed(2)}%`);
});

//网卡
const networksObj = os.networkInterfaces();
for(let nw in networksObj){
    let objArr = networksObj[nw];
    console.log(`\r\n${nw}:`);
    objArr.forEach((obj,idx,arr)=>{
        console.log(`地址:${obj.address}`);
        console.log(`掩码:${obj.netmask}`);
        console.log(`物理地址:${obj.mac}`);
        console.log(`协议族:${obj.family}`);
    });
}

一三、修改文件或目录的操作权限

//fs.utimes(path,
mode, callback);

/**

 * path,
要查看目录/文件的总体路径及名;

 * mode,
钦点权限,如:066陆 八进制,权限:全部用户可读、写,

 *
[callback(err)], 操作实现回调函数;err操作退步对象

 */

 

1.       
fs.chmod(__dirname + ‘/fsDir’,
0666, function (err) {

2.       
    if(err) {

3.       
        console.error(err);

4.       
        return;

5.       
    }

六.       
    console.log(‘修改权限成功’)

7.       
});

 

stream

1四、移动/重命名文件或目录

//fs.rename(oldPath, newPath,
callback);

/**

 * oldPath, 原目录/文件的总体路径及名;

 * newPath, 新目录/文件的完整路径及名;借使新路线与原路径相同,而只文件名分歧,则是重命名

 *
[callback(err)], 操作达成回调函数;err操作失利对象

 */

 

1.       
fs.rename(__dirname + ‘/test’, __dirname + ‘/fsDir’,
function (err) {

2.       
    if(err) {

3.       
        console.error(err);

4.       
        return;

5.       
    }

陆.       
    console.log(‘重命名成功’)

7.       
});

怎么使用流

nodejs的fs模块并不曾提供二个copy的艺术,但大家能够很简单的贯彻三个,比如:

var source = fs.readFileSync('/path/to/source', {encoding: 'utf8'});
fs.writeFileSync('/path/to/dest', source);

地点的这段代码并从未什么样难题,可是在每一趟请求时,我们都会把全部源文件读入到内部存款和储蓄器中,然后再把结果再次回到给客户端。想想看,若是源文件丰硕大,在响应大批量用户的出现请求时,程序恐怕会费用大量的内部存款和储蓄器,那样很只怕会招致用户连接缓慢的难题。

得天独厚的点子应该是读一些,写1些,不管文件有多大,只要时刻允许,总会处理到位,这里就供给用到流的定义。

地方的公文复制能够大概完成一下:

var fs = require('fs');
var readStream = fs.createReadStream('/path/to/source');
var writeStream = fs.createWriteStream('/path/to/dest');

readStream.on('data', function(chunk) { // 当有数据流出时,写入数据
    writeStream.write(chunk);
});

readStream.on('end', function() { // 当没有数据时,关闭数据流
    writeStream.end();
});

上边包车型客车写法有一对标题,假诺写入的进度跟不上读取的进程,有望造成数据丢失。平时的景观应该是,写完一段,再读取下1段,假使未有写完的话,就让读取流先暂停,等写完再持续,于是代码能够修改为:

var fs = require('fs');
var readStream = fs.createReadStream('/path/to/source');
var writeStream = fs.createWriteStream('/path/to/dest');

readStream.on('data', function(chunk) { // 当有数据流出时,写入数据
    if (writeStream.write(chunk) === false) { // 如果没有写完,暂停读取流
        readStream.pause();
    }
});

writeStream.on('drain', function() { // 写完后,继续读取
    readStream.resume();
});

readStream.on('end', function() { // 当没有数据时,关闭数据流
    writeStream.end();
});

也许应用更直接的pipe

// pipe自动调用了data,end等事件
fs.createReadStream('/path/to/source').pipe(fs.createWriteStream('/path/to/dest'));

上边是三个完完全全的复制文件的长河

var fs = require('fs'),
    path = require('path'),
    out = process.stdout;

var filePath = 'Users/feng/Documents/something/kobe.gif';

var readStream = fs.createReadStream(filePath);
var writeStream = fs.createWriteStream('file.gif');

var stat = fs.statSync(filePath);

var totalSize = stat.size;
var passedLength = 0;
var lastSize = 0;
var startTime = Date.now();

readStream.on('data', function(chunk) {

    passedLength += chunk.length;

    if (writeStream.write(chunk) === false) {
        readStream.pause();
    }
});

readStream.on('end', function() {
    writeStream.end();
});

writeStream.on('drain', function() {
    readStream.resume();
});

setTimeout(function show() {
    var percent = Math.ceil((passedLength / totalSize) * 100);
    var size = Math.ceil(passedLength / 1000000);
    var diff = size - lastSize;
    lastSize = size;
    out.clearLine();
    out.cursorTo(0);
    out.write('已完成' + size + 'MB, ' + percent + '%, 速度:' + diff + 'MB/s');
    if (passedLength < totalSize) {
        setTimeout(show, 500);
    } else {
        var endTime = Date.now();
        console.log();
        console.log('共用时:' + (endTime - startTime) / 1000 + '秒。');
    }
}, 500);

一伍、删除空目录

//fs.rmdir(path,
callback);

/**

 * path,
目录的全部路径及目录名;

 *
[callback(err)], 操作达成回调函数;err操作退步对象

 */

1.       
fs.rmdir(__dirname + ‘/test’, function (err) {

2.       
    fs.mkdir(__dirname + ‘/test’, 0666, function (err) {

3.       
        console.log(‘创建test目录’);

4.       
    });

5.       
 

6.       
    if(err) {

柒.       
        console.log(‘删除空目录战败,恐怕原因:一、目录不设有,二、目录不为空’)

8.       
        console.error(err);

9.       
        return;

10.         }

11.      

1二.         console.log(‘删除空目录成功!’);

13.     });

 

Readable流

fs.createReadStream(path[, options])用来打开二个可读的文本流,它回到3个fs.ReadStream指标。path参数钦赐文件的路线,可选的options是叁个JS对象,可以钦命一些增选,类似上面那样:

{ flags: 'r',
  encoding: 'utf8',
  fd: null,
  mode: 0666,
  autoClose: true
}

options的flags属性钦赐用什么形式打开文件:

  • ’w’代表写,’r’代表读,类似的还有’r+’、’w+’、’a’等,与Linux下的open函数接受的读写形式类似。
  • encoding钦定打开文件时使用编码格式,私下认可正是“utf八”,你还足以为它钦定”ascii”或”base6四”。
  • fd属性暗中认可为null,当你钦定了那特个性时,createReadableStream会根据传入的fd创立八个流,忽略path。此外你壹旦想读取三个文件的一定区域,能够安插start、end属性,内定早先和了结(包括在内)的字节偏移。
  • autoClose属性为true(暗中认可行为)时,当产生错误或文件读取结束时会自动关闭文件讲述符。

Readable还提供了一部分函数,大家能够用它们读取或操作流:

  • read([size]):假使您给read方法传递了多个制订大小作为参数,那它会回到钦定数量的数量,即便数据不足,就会再次回到null。如果你不给read方法传参,它会回来内部缓冲区里的保有数据,如若未有数据,会回去null,此时有相当的大希望表明境遇了文本末尾。read重返的多寡恐怕是Buffer对象,也或者是String对象。
  • setEncoding(encoding):给流设置三个编码格式,用于解码读到的数额。调用此措施后,read([size])方法再次来到String对象。
  • pause():暂停可读流,不再产生data事件
  • resume():恢复生机可读流,继续发生data事件
  • pipe(destination,[options]):把这一个可读流的出口传递给destination钦点的Writable流,三个流组成叁个管道。options是3个JS对象,那些指标有3个布尔类型的end属性,私下认可值为true,当end为true时,Readable截止时自动终止Writable。注意,大家得以把1个Readable与若干Writable连在一齐,组成多个管道,每二个Writable都能获得平等的数码。那些办法再次来到destination,若是destination本人又是Readable流,就足以级联调用pipe(比如大家在选取gzip压缩、解压缩时就会如此,立刻会讲到)。
  • unpipe([destination]):端口与钦赐destination的管道。不传递destination时,断开与这些可读流连在1齐的具有管道。

Readable流提供了以下事件:

  • readable:在数量块能够从流中读取的时候发生。它对应的电脑没有参数,可以在电脑里调用read([size])方法读取数据。
  • data:有多少可读时发生。它对应的微处理器有贰个参数,代表数量。借使您只想急速地读取1个流的数据,给data关联八个电脑是最有利的主意。处理器的参数是Buffer对象,如若你调用了Readable的setEncoding(encoding)方法,处理器的参数就是String对象。
  • end:当数码被读完时发出。对应的微型计算机未有参数。
  • close:当底层的能源,如文件,已关门时发出。不是负有的Readable流都会发出那个事件。对应的微型总计机没有参数。
  • error:当在接收数据中出现错误时发出。对应的微型计算机参数是Error的实例,它的message属性描述了错误原因,stack属性保存了发生错误时的库房音信。

四个核心的可读流实例

var fs = require('fs');

var readable = fs.createReadStream('text.js',{
  flags: 'r',
  encoding: 'utf8',
  autoClose: true,
  mode: 0666,
});

readable.on('open', function(fd){
  console.log('file was opened, fd - ', fd);
});

readable.on('readable', function(){
  console.log('received readable');
});

readable.on('data', function(chunk){
  console.log('read %d bytes: %s', chunk.length, chunk);
});

readable.on('end', function(){
  console.log('read end');
});

readable.on('close', function(){
  console.log('file was closed.');
});

readable.on('error', function(err){
  console.log('error occured: %s', err.message);
});

16、监视文件

//对文本进行蹲点,并且在监视到文件被涂改时进行拍卖

//fs.watchFile(filename, [options], listener);

/**

 * filename,
完整路径及文件名;

 *
[options], persistent true代表持续监视,不脱离程序;interval 单位微秒,表示每隔多少阿秒监视一遍文件

 * listener,
文件发生变化时回调,有三个参数:curr为三个fs.Stat对象,被改动后文件,prev,3个fs.Stat对象,表示修改前对象

 */

1.       
fs.watchFile(__dirname + ‘/test.txt’, {interval: 20}, function (curr,
prev) {

2.       
    if(Date.parse(prev.ctime) == 0) {

三.       
        console.log(‘文件被创建!’);

4.       
    } else if(Date.parse(curr.ctime) == 0) {

5.       
        console.log(‘文件被剔除!’)

6.       
    } else if(Date.parse(curr.mtime) != Date.parse(prev.mtime)) {

七.       
        console.log(‘文件有修改’);

8.       
    }

9.       
});

10.      

11.     fs.watchFile(__dirname + ‘/test.txt’, function (curr,
prev) {

12.         console.log(‘那是第1个watch,监视到文件有修改’);

13.     });

 

Writable

Writable流提供了3个接口,用来把多少写入到指标设备(或内部存储器)中。

Writable提供了一些函数来操作流

  • write(chunk[,encoding][,callback])能够把数量写入流中。个中,chunk是待写入的多少,是Buffer或String对象。那一个参数是必须的,别的参数都以可选的。假诺chunk是String对象,encoding能够用来钦命字符串的编码格式,write会依照编码格式将chunk解码成字节流再来写入。callback是数量完全刷新到流中时会执行的回调函数。write方法再次来到布尔值,当数码被完全处理后归来true(不自然是截然写入设备哦)。

  • end([chunk] [,encoding][,callback])办法能够用来终止三个可写流。它的五个参数都是可选的。chunk和encoding的意义与write方法类似。callback是七个可选的回调,当你提供它时,它会被波及到Writable的finish事件上,那样当finish事件发射时它就会被调用。

今昔大家来探视Writable公开的轩然大波:

finish:
在end()被调用、全部数据都已被写入底层设备后发射。对应的总计机函数未有参数。
pipe:
当你在Readable流上调用pipe()方法时,Writable流会发射那一个事件,对应的拍卖器函数有三个参数,类型是Readable,指向与它总是的不得了Readable流。
unpipe:
当你在Readable流上调用unpipe()方法时,Writable流会发射那一个事件,对应的拍卖器函数有一个参数,类型是Readable,指向与刚与它断开连接的不胜Readable流。
error: 出错开上下班时间发射,对应的总结机函数的参数是Error对象。

看叁个简易实例

var fs = require('fs');

var writable = fs.createWriteStream('example.txt',{
  flags: 'w',
  defaultEncoding: 'utf8',
  mode: 0666,
});

writable.on('finish', function(){
  console.log('write finished');
  process.exit(0);
});

writable.on('error', function(err){
  console.log('write error - %s', err.message);
});

writable.write('hello 地方', 'utf8');

writable.end();

17、撤消监视文件

//废除对文件举行监视

//fs.unwatchFile(filename, [listener]);

/**

 * filename,
完整路径及文件名;

 *
[listener], 要撤消的监听器事件,如若不钦赐,则废除全数监听处监护人件

 */

1.       
var listener =
function (curr, prev) {

二.       
    console.log(‘小编是监视函数’)

3.       
}

4.       
fs.unwatchFile(__dirname + ‘/test.txt’, listener);

 

1陆、监视文件或目录

// 对文件或目录进行蹲点,并且在监视到修改时进行拍卖;

// fs.watch再次来到3个fs.FS沃特cher对象,拥有2个close方法,用于结束watch操作;

// 当fs.watch有文件变化时,会触发fs.FS沃特cher对象的change(err, filename)事件,err错误对象,filename发生变化的文本名

// fs.watch(filename, [options], [listener]);

/**

 * filename,
完整路径及文件名或目录名;

 *
[listener(event, filename], 监听器事件,有八个参数:event 为rename表示钦赐的文书或目录中有重命名、删除或移动操作或change表示有改动,filename表示产生变化的文本路径

 */

 

1.       
var fsWatcher = fs.watch(__dirname + ‘/test’, function (event, filename) {

2.       
    //console.log(event)

3.       
});

4.       
 

5.       
//console.log(fsWatcher instanceof FSWatcher);

6.       
 

7.       
fsWatcher.on(‘change’,
function (event, filename) {

8.       
    console.log(filename + ‘ 产生变化’)

9.       
});

10.      

1一.     //30秒后关门监视

12.     setTimeout(function () {

13.         console.log(‘关闭’)

14.         fsWatcher.close(function (err) {

15.             if(err) {

16.                 console.error(err)

17.             }

18.             console.log(‘关闭watch’)

19.         });

20.     },
30000);

 

其他流

18、文件流

/*

 *
流,在应用程序中意味着1组有序的、有源点有极限的字节数据的传输手段;

 *
Node.js中贯彻了stream.Readable/stream.Writeable接口的指标开始展览流数据读写;以上接口都持续自伊芙ntEmitter类,因而在读/写流不一致情形时,触发不一致事件;

 *
关于流读取:Node.js不断将文件一小块内容读入缓冲区,再从缓冲区中读取内容;

 *
关于流写入:Node.js不断将流多少写入内在缓冲区,待缓冲区满后再将缓冲区写入到文件中;重复下面操作直到要写入内容写写完;

 * readFile、read、writeFile、write都以将1切文件放入内部存款和储蓄器而再操作,而则是文本一部分数额一部分数额操作;

 *

 *
———————–流读取————————————-

 *
读取数据对象:

 * fs.ReadStream 读取文件

 * http.IncomingMessage 客户端请求或劳动器端响应

澳门葡京 , * net.Socket   
Socket端口对象

 * child.stdout 
子进度正式输出

 * child.stdin  
子进度标准入

 * process.stdin 用于创立进程正式输入流

 * Gzip、Deflate、DeflateRaw   数据压缩

 *

 *
触发事件:

 *
readable  数据可读时

 * data      数据读取后

 * end       数据读取实现时

 *
error     数据读取错误时

 *
close     关闭流对象时

 *

 *
读取数据的靶子操作方法:

 * read      读取数据方法

 * setEncoding  
设置读取数据的编码

 *
pause     文告对象众目结束触发data事件

 *
resume    通告对象苏醒触发data事件

 * pipe      设置数据通道,将读入流数据连接写入流;

 * unpipe   
撤销通道

 * unshift  
当流数据绑定贰个解析器时,此方法撤消解析器

 *

 *
————————流写入————————————-

 *
写数据对象:

 * fs.WriteStream           写入文件对象

 * http.clientRequest       写入HTTP客户端请求数据

 * http.ServerResponse      写入HTTP服务器端响应数据

 * net.Socket               读写TCP流或UNIX流,需求connection事件传递给用户

 * child.stdout             子进程正式输出

 * child.stdin              子进程标准入

 * Gzip、Deflate、DeflateRaw  数据压缩

 *

 *
写入数据触发事件:

 *
drain            当write方法重返false时,表示缓存区中壹度出口到指标对象中,能够继续写入数据到缓存区

 *
finish           当end方法调用,全体数据写入完毕

 * pipe             当用于读取数据的靶子的pipe方法被调用时

 * unpipe          
当unpipe方法被调用

 *
error            当发生错误

 *

 *
写入数据模式:

 *
write            用于写入数据

 * end              甘休写入,之后再写入会报错;

 */

 

参考文章

nodejs
stream手册

1玖、创制读取流

//fs.createReadStream(path, [options])

/**

 * path
文件路径

 *
[options] flags:钦点文件操作,暗许’r’,读操作;encoding,钦定读取流编码;autoClose, 是不是读取实现后活动关闭,暗中认可true;start钦命文件开首读取地方;end内定文件早先读甘休地点

 */

1.       
var rs = fs.createReadStream(__dirname + ‘/test.txt’, {start: 0, end: 2});

2.       
 

3.       
//open是ReadStream对象中表示文件打开时事件,

4.       
rs.on(‘open’, function (fd)
{

伍.       
    console.log(‘初始读取文件’);

6.       
});

7.       
 

8.       
rs.on(‘data’, function (data) {

9.       
    console.log(data.toString());

10.     });

11.      

12.     rs.on(‘end’, function () {

一叁.         console.log(‘读取文件结束’)

14.     });

15.      

16.     rs.on(‘close’, function () {

一七.         console.log(‘文件关闭’);

18.     });

19.      

20.     rs.on(‘error’,
function (err) {

21.         console.error(err);

22.     });

23.      

二肆.     //暂停和还原来的小说件读取;

25.      

26.     rs.on(‘open’, function () {

二柒.         console.log(‘早先读取文件’);

28.     });

29.      

30.     rs.pause();

31.      

32.     rs.on(‘data’, function (data) {

33.         console.log(data.toString());

34.     });

35.      

36.     setTimeout(function () {

37.         rs.resume();

38.     },
2000);

别的壹类别小说

Nodejs模块学习笔记
极客学院nodejs官方文书档案

20、创造写入流

//fs.createWriteStream(path, [options])

/**

 * path
文件路径

 *
[options] flags:钦定文件操作,暗中同意’w’,;encoding,钦赐读取流编码;start钦定写入文件的职责

 */

 

/* ws.write(chunk,
[encoding], [callback]);

 *
chunk,  能够为Buffer对象或四个字符串,要写入的数量

 *
[encoding],  编码

 *
[callback],  写入后回调

 */

 

/* ws.end([chunk],
[encoding], [callback]);

 *
[chunk],  要写入的多少

 *
[encoding],  编码

 *
[callback],  写入后回调

 */

 

1.       
var ws = fs.createWriteStream(__dirname + ‘/test.txt’, {start: 0});

2.       
 

三.       
var buffer =
new Buffer(‘小编也喜欢你’);

4.       
 

5.       
 

6.       
ws.write(buffer,
‘utf8’, function (err, buffer)
{

7.       
    console.log(arguments);

捌.       
    console.log(‘写入实现,回调函数没有参数’)

9.       
});

10.      

1一.     //最终再写入的剧情

12.     ws.end(‘再见’);

13.      

14.     //使用流完了复制文件操作

15.     var rs = fs.createReadStream(__dirname + ‘/test.txt’)

16.     var ws = fs.createWriteStream(__dirname + ‘/test/test.txt’);

17.     rs.on(‘data’, function (data) {

18.         ws.write(data)

19.     });

20.      

21.     ws.on(‘open’, function (fd)
{

2贰.         console.log(‘要写入的数据文件已经打开,文件讲述符是: ‘ + fd);

23.     });

24.      

25.     rs.on(‘end’, function () {

二陆.         console.log(‘文件读取完结’);

27.      

28.         ws.end(‘完成’, function () {

2九.             console.log(‘文件全体写入完毕’)

30.         });

31.     });

 

//关于WriteStream对象的write方法重回三个布尔类型,当缓存区中多少总体写满时,再次回到false;

//表示缓存区写满,并将立即输出到对象对象中

 

//第一个例子

1.       
var ws = fs.createWriteStream(__dirname + ‘/test/test.txt’);

2.       
for (var i = 0; i < 10000;
i++) {

3.       
    var w_flag = ws.write(i.toString());

4.       
    //当缓存区写满时,输出false

5.       
    console.log(w_flag);

6.       
}

 

//第2个例子

1.       
var ws = fs.createWriteStream(__dirname + ‘/test/untiyou.mp3’);

2.       
var rs = fs.createReadStream(__dirname + ‘/test/Until You.mp3’);

3.       
rs.on(‘data’, function (data) {

4.       
    var flag = ws.write(data);

5.       
    console.log(flag);

6.       
});

7.       
 

八.       
//系统缓存区数据已经整整输出触发drain事件

9.       
ws.on(‘drain’,
function () {

10.         console.log(‘系统缓存区数据现已整整出口。’)

11.     });

 

未完待续~

二一、管道pipe完成流读写

//rs.pipe(destination, [options]);

/**

 *
destination 必须贰个可写入流数据对象

 * [opations] end 默许为true,表示读取实现马上关闭文件;

 */

 

1.       
var rs = fs.createReadStream(__dirname + ‘/test/Until You.mp3’);

2.       
var ws = fs.createWriteStream(__dirname + ‘/test/untiyou.mp3’);

3.       
rs.pipe(ws);

4.       
 

5.       
rs.on(‘data’, function (data) {

陆.       
    console.log(‘数据可读’)

7.       
});

8.       
 

9.       
rs.on(‘end’, function () {

10.         console.log(‘文件读取完结’);

11.         //ws.end(‘再见’)

12.     });

 

//———————路径操作————————-

2二、路径解析,拿到规范化的路子格式

//对window系统,目录分隔为’\’, 对于UNIX系统,分隔符为’/’,针对’..’再次来到上顶级;/与\\都被统一更换

//path.normalize(p);

 

1.       
var myPath = path.normalize(__dirname + ‘/test/a//b//../c/utilyou.mp3’);

2.       
console.log(myPath); //windows:
E:\workspace\NodeJS\app\fs\test\a\c\utilyou.mp3

 

贰3、路径结合、合并,路径最终不会带目录分隔符

//path.join([path1],[path2]..[pathn]);

/**

 * [path1]
路径或表示目录的字符,

 */

 

1.       
var path1 =
‘path1’,

2.       
    path2 = ‘path2//pp\\’,

3.       
    path3 = ‘../path3’

4.       
 

5.       
var myPath = path.join(path1, path2, path3);

6.       
console.log(myPath); //path1\path2\path3

2四、获取相对路径

//path.resolve(path1, [path2]..[pathn]);

//以应用程序为源点,根据参数字符串解析出二个相对路径

/**

 * path
必须至少二个途径字符串值

 * [pathn] 可选路径字符串

 */

1.       
var myPath = path.resolve(‘path1’, ‘path2’,
‘a/b\\c/’);

2.       
console.log(myPath);//E:\workspace\NodeJS\path1\path2\a\b\c

 

二5、获取相对路径

//path.relative(from, to);

//获取两路子之间的相对关系

/**

 * from
当前路线,并且方法重返值是基于from钦定到to的相对路径

 * to   到哪路径,

 */

1.       
var from =
‘c:\\from\\a\\’,

2.       
    to = ‘c:/test/b’;

3.       
var _path =
path.relative(from, to);

4.       
console.log(_path); //..\..\test\b; 表示从from到to的相对路径

 

26、path.dirname(p)

// 获取路径中目录名

1.       
var myPath = path.dirname(__dirname + ‘/test/util
you.mp3’);

2.       
console.log(myPath);

 

27、path.basename(path, [ext])

// 获取路径汉语件名,后缀是可选的,若是加,请使用’.ext’格局来合作,则再次来到值中不包蕴后缀名;

1.       
var myPath = path.basename(__dirname + ‘/test/util
you.mp3’, ‘.mp3’);

2.       
console.log(myPath);

 

28、path.extname(path)

赢得路径中的扩张名,即便未有’.’,则赶回空

 

29、path.sep属性

重返操作系统汉语件分隔符; window是’\\’, Unix是’/’

 

30、path.delimiter属性

回来操作系统中目录分隔符,如window是’;’, Unix中是’:’

 

 

参考:

《Node.js权威指南》之在Node.js中操作文件系统

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website