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)
        })
    })
})