node知识积累

 // 在node的应用程序中，执行异步操作的函数将回掉函数最为最后一个参数，回掉函数接收错误对象作为第一个参数
 var fs = require('fs')
 fs.readFile('input.txt',function (err,data) {//这个是异步函数，用于读取文件；
     if(err){
         console.log(err.stack)
         return
     }
     console.log(data.toString())
 })
 console.log('程序执行完毕')

 // 执行结果：
 // 程序执行完毕
 // 菜鸟教程官网地址：www.runoob.com

二：

 // EventEmitter
 node.js中所有异步操作，在完成时都会发送一个事件到事件队列；
 node.js里面有很多对象都会分发事件：一个net.server对象会在每次有新连接时触发一个事件。一个fs.readStream对象会在文件被打开的时候触发一个事件；所有这些产生事件
 // 的对象都是events.EventEmitter的实例
 events模块只提供了一个对象；events.EventEmitter.EventEmitter的核心就是事件触发与事件监听功能的封装；
 var EventEmitter = require('events').EventEmitter;
 var event   = new EventEmitter();
 event.on('some_event',function () {
     console.log('some_event事件触发')
 })
 setTimeout(function(){
     event.emit('some_event')
 },2000)

 原理分析：event对象注册了事件some_event的一个监听器，通过setTimeout在2s后向event对象发送some_event,此时会调用some_event监听器

 对于每个事件，EventEmitter支持若干个事件监听器；当事件触发时，注册到这个事件的事件监听器被一次调用，事件参数作为回调函数参数传递

 var events = require('events')
 var emitter = new events.EventEmitter();
 emitter.on('someEvent',function(arg1,arg2){
     console.log('listener1',arg1,arg2)
 })
 emitter.on('someEvent',function(arg1,arg2){
     console.log('listener2',arg1,arg2)
 })
 emitter.emit('someEvent','arg1参数','arg2参数')

 运行结果：
 $ node event.js
 listener1 arg1 参数 arg2 参数
 listener2 arg1 参数 arg2 参数
 分析：emitter为事件someEvent注册了两个事件监听器，然后触发了someEvent事件；

 emiter的方法：
 addListener(event,listener)为指定事件添加一个监听器到监听器数组的尾部；
 on(event,listener)为指定事件注册一个监听器，接受一个字符串event和一个回掉函数
 onece(event,listener)为指定事件注册一个单次监听器，
 removeListener(event,listener)移除指定事件的某个监听器，监听器必须是该事件已经注册过的监听器
 removeAllLissteners([event])移除所有事件的所有监听器，如果指定事件，则移除指定事件的所有监听器；
 setMaxListeners(n)默认情况下，EventEmitters如果你添加的监听器超过10个就会是输出警告信息，setMaxListeners用于提高监听器默认限制的数量
 listeners(event)返回指定始事件的监听器数组
 emit(event,[arg1],[arg2],[...])按参数的顺序执行每个监听器；
 事件：
 // newListener该事件在添加新的监听器时触发；
 // removeListener在移除监听器的时候触发；

 实例：
 var events = require('events')
 var eventEmitter = new events.EventEmitter();
 var listener1 = function listener1() {
     console.log('监听器listener1执行')
 }
 var listener2 = function listener1() {
     console.log('监听器listener2执行')
 }
 // 绑定 connection 事件，处理函数为 listener1 /2
 eventEmitter.addListener('connection',listener1)
 eventEmitter.addListener('connection',listener2)

 var eventListeners = eventEmitter.listenerCount('connection')
 console.log(eventListeners+'个监听器监听连接事件')
 eventEmitter.emit('connection')

 eventEmitter.removeListener('connection',listener1)
 console.log('listener1不再受监听')

 eventEmitter.emit('connection')

 eventListeners = eventEmitter.listenerCount('connection')
 console.log(eventListeners+ "个监听器")
 console.log('程序执行完毕')
 error事件

 // Buffer(缓冲区)
 // Buffer类专门用来存放二进制数据的缓存区
 //  Buffer实例一般用于标识编码字符的序列,,比如 UTF-8 、 UCS2 、 Base64 、或十六进制编码的数据。 通过使用显式的字符编码，就可以在 Buffer 实例与普通的 JavaScript 字符串之间进行相互转换。
 var buf = Buffer.from ('bobobo','ascii')
 console.log(buf.toString('hex'))
 console.log(buf.toString('base64'))

 Stream(流)
 Stream是一个抽象接口,node中有很多对象实现了这个接口,例如,对http服务器发起请求的request对象就是一个Stream;
 Stream有四种流类型:
 Readable- -- 可读操作
 Writable 可写操作
 Duplex可读可写
 Transform操作被写入输入,然后读出结果;
 所有的Stream对象都是EventEmitter的实例,常用的事件有:
 data 当数据可读时触发
 end没有更多数据可读时触发
 error在接收和写入过程中发生错误时候触发
 finish所有数据已被写如底层系统时候触发;

 实例:从流中读取数据
 var fs= require ('fs')
 var data =''
 // 创建可读流
 var readerStream  = fs.createReadStream('input.txt')
 // 设置编码
 readerStream.setEncoding('UTF8')
 // 处理流事件 data end error
 readerStream.on('data',function(chunk){
     data += chunk;
 })
 readerStream.on('end',function () {
     console.log(data)
 })
 readerStream.on('error',function (err) {
     console.log(err.stack)
 })
 console.log('程序执行完毕')
 实例:写入流
 var fs = require('fs')
 var data = '我是邓艳波'
 //创建一个可以写入的流,写入到文件input.txt中
 var writeStream = fs.createWriteStream('input.txt');
 //设置编码
 writeStream.write(data,'UTF8')
 //标记文件末尾
 writeStream.end()
 //处理流事件 --data ,end,error
 writeStream.on('finish',function () {
     console.log('写入完成')
 })
 writeStream.on('error',function (err) {
     console.log(err)
 })
 console.log('程序执行完毕')

 管道流:提供了一个输出流到输入流的机制,通常我们用于从一个流中获取数据并将数据传递到另一个流中;
 var fs = require('fs')
 //创建一个可读流
 var  readerStream = fs.createReadStream('input.txt')
 //创建一个可写流
 var writerStream = fs.createWriteStream('output.txt')
 //管道读写操作,将input.txt内容写到output.txt中
 readerStream.pipe(writerStream)
 console.log('程序执行完毕')

 链式流:通过连接输出流到另外一个流并创建多个流操作链的机制;链式流一般用于管道操作
 实例:利用管道和链式压缩和解压文件
 var fs=require('fs')
 var zlib= require('zlib')
 //压缩所文件input.txt为input.txt.gz
 fs.createReadStream('input.txt')
   .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('input.txt.gz'))
 console.log('文件压缩完成')

 解压文件:
 var fs = require('fs')
 var zlib = require('zlib')
 fs.createReadStream('input.txt.gz')
     .pipe(zlib.createGunzip())
     .pipe(fs.createWriteStream('input.txt'))
 console.log('文件解压完成')

 // node.js的模块系统
 // 作用:方便node.js的文件可以相互调用;一个node.js文件就是一个模块;
 // 创建模块:
 // var world = require('./world');
 // world.world()

 // world.js文件内容:
 // // exports.world = function () {
 // //     console.log('hello bobo')
 // // }

 // 分析:world.js通过exports对象把world作为模块的访问接口,在hello.js中,引入加载这个模块,然后就可以直接访问world.js中exports对象的成员函数了;
 // 若知识想把一个对象封装到模块中,则:
 // module.exports = function () {
 //
 // }
 // 实例:

 // world.js
 // function world(){
 //     var name ;
 //     this.setName = function (thyName) {
 //         name = thyName
 //     };
 //     this.setHello = function () {
 //         console.log('hello  ' + name)
 //     }
 // }
 // module.exports = world;
 //
 // // hello.js
 // var World = require('./world')
 //    world = new World();
 //    world.setName('DengYanbo')
 //    world.setHello()
 //
 // 输出:hello DengYanbo

 Node.js函数:
 在js中,一个函数可以作为另外一个 函数的参数,我们可以先定义一个函数,然后传递,也可以在传递参数的地方直接定义函数;
 举例:
 function say(word){
     console.log(word)
 }
 function execute(someFunction,value) {
     someFunction(value)
 }
 execute(say,'hello')
 分析:打印出hello

 函数传递时如何让http服务器工作的:
 var http = require('http')
 http.createServer(function (request,response) {
     response.writeHead(200,{'Content-Type':'text/plain'});
     response.write('hello world');
     response.end()
 }).listen(8888)

 // Node.js路由:
 //    我们要为路由提供请求的URL和其他需要的GET及post参数,随后路由需要根据这些数据执行相应的代码.
 //        因此我们需要查看HTTP请求,从中提取出请求的URL以及get/post参数.
 //        我们需要的所有是数据都会包含在request对象中,该对象作为onRequest()回调函数的第一个参数传递,但是为了解析这些数据,我们需要额外的node.js模块,他们分别是url和querystring模块;

 // server.js
 var  http = require('http')
 var url = require('url')
 function start(route) {
     function onRequest(request,response) {
         var pathname = url.parse(request.url).pathname;
         console.log('Request for' +pathname +'received.')
         //将路由函数作为参数传递过去
         route(pathname)
         response.writeHead(200,{'Content-Type':'text/plain'});
         response.write('hello world');
         response.end()
     }

     http.createServer(onRequest).listen(8888);
     console.log('Server has started')
 }
 exports.start = start

 // router.js
 function route(pathname) {
     console.log('About to route a request for' +pathname)
 }
 exports.route = route
 // 如何将路由和服务器整合起来:

 // index.js
 var server = require('./hello')
 var router = require('./router')
 server.start(router.route)

 Node.js的全局对象:
    js的全局对象时window,node的全局对象是global;
 _fileName:当前正在执行的脚本的文件名,将输出文件所在位置的绝对路径,且和命令行参数所指定的文件名不一定相同,如果在模块中,返回的是模块文件的路径
 console.log(__filename)//C:\Users\yangguoe\Desktop\node Project\hello.js
 _dirname:当前执行脚本所在的目录
 console.log( __dirname  )////C:\Users\yangguoe\Desktop\node Project
 注意:是两个下划线
 setTimeout(cb,ms)全局函数在指定的ms后执行指定函数cb;
 function printHello() {
     console.log('hello world')
 }
 setTimeout(printHello,2000)
 clearTimeout(t)停止一个之前通过setTimeout()创建的定时器;参数t是通过setTimeout()函数创建的定时器;
 function printHello(){
     console.log('hello world')
 }
 var t = setTimeout(printHello,200)
 clearTimeout(t)
 setInterval(cb,ms)//在指定的毫秒数后执行指定函数;
 function printHello (){
     console.log('hello bobo')
 }
 setInterval(printHello,200)

 console方法:
 console.log()
 console.info()//输出信息性消息
 console.error()//输出错误消息
 console.warn()
 console.dir()用来对一个对象进行检查,并以易于阅读和打印的格式显示
 console.time()/输出事件,表示计时开始
 console.timeEnd()//结束时间,标识计时结束

 process:用于描述当前Node.js进程状态的对象;提供了一个与操作系统的简单接口;
         exit:当进程准备退出时触发;
         beforeExit:当node清空事件循环,并且没有其他安排时触发这个事件;
         Signal:当进程接收到信号时就触发;

 process.on('exit',function (code) {
     //以下代码永远不会执行
     setTimeout(function () {
         console.log('该代码不会执行')
     },0)
     console.log('退出码为:',code)
 })
 console.log('程序执行结束')

 执行结果为:
     程序执行结束
     退出码为: 0

 Node.js的文件系统;
 var fs = require('fs')
 //异步读取
 fs.readFile('input.txt',function (err,data) {
     if(err){
         return console.error(err)
     }
     console.log('异步读取:'+data.toString())
 })

 //同步读取
 var data = fs.readFileSync('input.txt')
 console.log('同步读取:'+data.toString())
 console.log('程序执行完毕')

 打开文件
 fs.open(path, flags[,mode],callback)
             path:文件路径
             flags:文件打开的行为:如r时以读取的模式;r+:读写模式;rs:同步读方式;rs+同步方式读写
             mode:设置文件模式(权限)
             callback:回调函数,带有两个参数:callback(err,fd)
 var fs = require('fs')
 //异步打开文件
 console.log('准备打开文件')
 fs.open('input.txt','r+',function (err,fd) {
     if(err){
         return console.error(err)
     }
     console.log('文件打开成功')
 })

 获取文件信息:fs.stat(path,callback)
             path:文件路径;
             callback:回调函数,带有两个参数(err,stats),stats是fs.Stats对象

 fs.stat(path)执行后,会将stats类的实例返回给其回调函数,可以通过stats类中的提供方法判断文件的相关属性.如判断是否为文件
 var fs = require('fs')
 fs.stat('C:/Users/yangguoe/Desktop/node Project/calc.js',function(err,stats){
     console.log(stats.isFile())//true
 })
 stats类中的方法有:
     stats.isFile()是否是文件
     stats.isDirectory()是否是目录
     stats.isBlockDevice()是否是块设备
     stats.isCharacterDevice()是否是字符设备
     stats.isSymbolicLink()是否是软连接
     stats.isFIFO()是否是FIFO
     stats.isSocket()是否是Socket

 var fs = require('fs')
 console.log('准备打开文件')
 fs.stat('input.txt',function(err,stats){
     if(err){
         return console.error(err)
     }
     console.log(stats)
     console.log('读取文件信息成功')

     //检测文件类型
     console.log('是否为文件(isFile)?'+ stats.isFile())
     console.log('是否为目录(isDirectory?' + stats.isDirectory())
 })

 打印结果为:
     准备打开文件！
 { dev: 16777220,
     mode: 33188,
     nlink: 1,
     uid: 501,
     gid: 20,
     rdev: 0,
     blksize: 4096,
     ino: 40333161,
     size: 61,
     blocks: 8,
     atime: Mon Sep 07 2015 17:43:55 GMT+0800 (CST),
     mtime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST),
     ctime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST) }
 读取文件信息成功！
 是否为文件(isFile) ? true
     是否为目录(isDirectory) ? false

 写入文件:fs.writeFile(file,data[,optionss],callback)
             file:文件名/文件描述符
             data:要写入文件的数据;
             options:是一个对象,包含{encoding,mode,flag}默认编码为 utf8, 模式为 0666 ， flag 为 'w'
             callback:回掉函数只包含错误信息参数书,在写入失败时候返回
 var fs = require('fs')
 console.log('准备写入文件')
 fs.writeFile('input.txt','我是通过fs.writeFile写入文件的内容',function (err) {
     if(err){
         return console.error(err)
     }
     console.log('数据写入成功')
     console.log("--------我是分割线-------------")
     console.log("读取写入的数据！");
     fs.readFile('input.txt',function (err,data) {
         if(err){
             return console.error(err)
         }
         console.log('异步读取文件数据:'+ data.toString())
     })
 })

 读取文件
 fs.read(fd,buffer,offset,length,position,callback)
             fd:通过fs.open()方法返回的文件描述符
             buffer:输入写入的缓冲区
             offset:缓冲区写入的写入偏移量
             length:要从文件中读取的字节数
             position:文件读取的起始位置:
             callback:三个参数:err,bytesRead,burrer,/错误信息/读取的字节数/缓冲区对象
 var fs = require("fs");
 var buf = new Buffer.alloc(1024);

 console.log("准备打开已存在的文件！");
 fs.open('input.txt', 'r+', function(err, fd) {
     if (err) {
         return console.error(err);
     }
     console.log("文件打开成功！");
     console.log("准备读取文件：");
     fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
         if (err){
             console.log(err);
         }
         console.log(bytes + "  字节被读取");

         // 仅输出读取的字节
         if(bytes > 0){
             console.log(buf.slice(0, bytes).toString());
         }
     });
 });

 关闭文件:fs.close(fd,callback)
         fd:通过fs.open()方法返回的文件描述符;
         callback:回掉函数,没有参数
 var fs = require('fs')
 var buf = new Buffer.alloc(1024)
 console.log('准备打开文件')
 fs.open('input.txt','r+',function (err,fd) {
     if(err){
         return console.error(err)
     }
     console.log("文件打开成功！");
     console.log("准备读取文件！");
     fs.read(fd,buf,0,buf.length,0,function (err,bytes) {
         if(err){
             console.log(err)
         }
         if(bytes >0){
             console.log(buf.slice(0,bytes).toString())
         }
         //关闭文件
         fs.close(fd,function (err) {
             if(err){
                 console.log(err)
             }
             console.log('关闭文件成功')
         })
     })
 })

 截取文件
 fs.ftruncate(fd,len,callback)
     fd:通过fs.open()方法 返回的文件描述符
     len:文件内容截取的长度
     callback:没有参数
 var fs = require("fs");
 var buf = new Buffer.alloc(1024);

 console.log("准备打开文件！");
 fs.open('input.txt', 'r+', function(err, fd) {
     if (err) {
         return console.error(err);
     }
     console.log("文件打开成功！");
     console.log("截取了10字节后的文件内容。");

     // 截取文件
     fs.ftruncate(fd, 10, function(err){
         if (err){
             console.log(err);
         }
         console.log("文件截取成功。");
         console.log("读取相同的文件");
         fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
             if (err){
                 console.log(err);
             }

             // 仅输出读取的字节
             if(bytes > 0){
                 console.log(buf.slice(0, bytes).toString());
             }

             // 关闭文件
             fs.close(fd, function(err){
                 if (err){
                     console.log(err);
                 }
                 console.log("文件关闭成功！");
             });
         });
     });
 });
 删除文件fs.unlink(path,callback)
 var fs = require('fs')
 console.log('准备删除文件')
 fs.unlink('input.txt',function (err) {
     if(err){
         return console.error(err)
     }
     console.log('文件 删除成功')
 })

 创建目录:fs.mkdir(path[,mode],callback)
         path:文件路径;
         mode:设置目录权限;默认为0777;
         callback:回掉函数,没有参数
 var fs = require('fs')
 console.log('创建目录/node Project/test')
 fs.mkdir('./index',function (err) {
     if(err){
         return console.error(err)
     }
     console.log('创建目录成功')
 })

 读取目录
 fs.readdir(path,callback)
 var fs=require('fs')
 console.log('查看/index目录')
 fs.readdir('./index/',function(err,files){
     if(err){
         return console.error(err)
     }
     files.forEach(function(file){
         console.log(file)
     })
 })

 // 删除目录:
 // fs.rmdir(path,callback)
 var fs= require('fs')
 //执行前创建一个空的目录
 console.log('准备删除目录./delete')
 fs.rmdir('./delete',function (err) {
     if(err){
         return console.error(err)
     }
     console.log('读取/delete目录')
     fs.readdir('./delete',function (err,files) {
         if(err){
             return console.error(err)
         }
         files.forEach(function (file) {
             console.log(file)
         })
     })
 })