全局变量
- console.log
- setTimeout，过x秒后执行
setTimeout(() => {
console.log("2s passed");
}, 2000);//两秒后执行console
- setInterval，每隔x秒执行。clearInterval，清除定时事件
var time = 0;
var timer = setInterval(() => {
time++;
console.log(`${time}秒过去了`);
if (time > 10)
clearInterval(timer);
}, 1000);
- __dirname，__filename
console.log(__dirname);//输出当前文件所在目录
console.log(__filename);//输出当前文件的地址
- require，export
模块
用于暴露函数，以便在其它文件中引用。
比如我在module.js中定义了两个函数
var add = function (a, b) {
return `${a}+${b}=${a + b}`;
}
var sub = function (a, b) {
return `${a}-${b}=${a - b}`;
}
module.exports = {
add,//表示add:add，如果函数名为adder，但是想暴露为add，则写成add:adder
sub
}
通过module.exports={}的方式暴露，在另一个js中，使用require引用
var xxx = require('./module.js');
console.log(xxx);//结果:{ add: [Function: add], sub: [Function: sub] }
可见引用的是一个对象，对象里面有两个方法，就是在module.js中定义的两个方法，通过xxx.xx的方式即可调用该方法
事件
- 绑定事件
var events = require('events');//调用事件库
//定义自己的事件
var myEmitter = new events.EventEmitter();
myEmitter.on('eventName', msg => {
console.log(msg);//定义触发事件时的回调函数
})
myEmitter.emit('eventName', 'the event was emitted');//触发事件
//结果：the event was emitted
- util继承事件库
var events = require('events');
var util = require('util');
var Person = function (name) {
this.name = name;
}
util.inherits(Person, events.EventEmitter);//让Person继承事件库，拥有绑定事件的方法
var xm = new Person('xiaoming');//xm:Person {name:'xiaoming'}
var dry = new Person('xiaoming');
var persons = [
xm,
dry,
new Person('xxx'),
];
persons.forEach(person => {
person.on('speak', msg => {//给Person中每个对象绑定一个speak事件
console.log(`${person.name} said: ${msg}`);
});
})
xm.emit('speak', 'yo good good');//xiaoming said: yo good good
persons[2].emit('speak', 'yo bad bad');//xxx said: yo bad bad
- ES6继承
看了眼官网，并不建议使用util.inherits()。而是建议使用ES6的
class和extends关键词获得语言层面的继承支持。所以代码改成:
var events = require('events');
const myEm = events.EventEmitter;
class Person extends myEm {
setName(name) {//设置名字方法
this.name = name;
};
callEvent(msg) {//触发事件方法，也可单独触发
this.emit('speak', msg);
};
}
var dry = new Person();
dry.setName('dry');
var xm = new Person();
xm.setName('xiaoming');
var xxx = new Person();
xxx.setName('xxx');
var persons = [
dry,
xm,
xxx
];
persons.forEach(person => {//给每个对象绑定事件
person.on('speak', msg => {
console.log(`${Person.name} said: ${msg}`);
});
});
dry.callEvent('yo good good ');
xm.emit('speak', 'yo bad bad');
文件
读/写
- 读
var fs = require('fs');
var lock = require('../../19.1.3/locks');
var readMe = fs.readFileSync("../readMe.txt", "utf8");
console.log("同步读取:" + readMe);
fs.readFile('../readMe.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log("异步读取:"+data );//'readMe.txt'中的内容
})
lock();//调用引入的阻塞函数，作用是阻塞4秒，上面异步读取文件里的内容会在阻塞4秒后最后显示
//结果：同步读取:you read me ! finished 异步读取:you read me !
- 写
var fs = require('fs');
fs.writeFileSync('../writeMe.txt', '...', 'utf8');//创建了writeMe.txt，内容为...
fs.writeFile("../writeMe1.txt", "异步写入文件", "utf8", (err) => {
if (err) throw err;
console.log("done!");
})
- 删除
fs.unlink('../writeMe1.txt', (err) => {
if (err) throw err;
console.log( "文件已删除");
})
- 创建/删除目录
var fs = require('fs');
fs.mkdirSync('stuff');//同步创建stuff目录
fs.rmdirSync('stuff');//只能删除空文件夹
一个拷贝内容的小例子
var fs = require('fs');
fs.mkdir('stuff', function () {//创建目录
fs.readFile('../readMe.txt', 'utf8', function (err, data) {//读取父目录下的readMe.txt中内容
if (err) throw err;
fs.writeFile('./stuff/writeMe.txt', data, function () {//创建writeMe.txt并把刚刚读取的内容写入
console.log('复制成功');
});
});
});
流(stream)和管道(pipe)
流
比如：
ls|grep txt ::输出包含txt的文件
这条命令就构成了一个流，ls输出了一个流，作为grep命令的输入。
在node.js中，对http的处理也是用流来处理的,请求就是一个输入的流，响应就是一个输出的流，所有的流都是EventEmitter的一个实例。
流的应用可以提高性能。比如在文件系统中，在文件很大的时候，使用流可以把文件放在很多buffer中进行分段处理，一边放一边处理。
- 读取流
var fs = require('fs');
var myReadStream = fs.createReadStream(__dirname + '\/..\/readMe.txt');//这里需要转义,如果要使得打印出来原内容，需要在最后一个参数加上'utf-8'。
myReadStream.on('data', function (chunk) {
console.log('new chunk received');
console.log(chunk);
})
//结果:new chunk received <Buffer 79 6f 75 20 72 65 61 64 20 6d 65 20 21>
var fs = require('fs');
var myReadStream = fs.createReadStream(__dirname + '\/..\/readMe.txt');
myReadStream.setEncoding('utf8');
var data = "";
myReadStream.on('data', function (chunk) {
data += chunk;
})
myReadStream.on('end', () => {
//监听结束输出data
console.log(data);
})
- 写入流
var fs = require('fs');
var myWriteStream = fs.createWriteStream(__dirname + '/writeMe.txt');
var writeData = "hello world!";
myWriteStream.write(writeData, 'utf8');
myWriteStream.end();//写入结束
myWriteStream.on('finish', () => {//创建一个结束的监听事件，或者回调写在end()里
console.log('finished');
})
用流和管道的方法重写上面的复制文件内容的小例子会变得非常简单
var fs = require('fs');
var myWriteStream = fs.createWriteStream(__dirname + '/writeMe.txt');
var myReadStream = fs.createReadStream(__dirname + '\\..\/readMe.txt');
myReadStream.pipe(myWriteStream);
http模块
- 纯文本
var http = require('http');
var server = http.createServer((req, res) => {
console.log('Request received');
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.write('Hello http');//也可直接写在end()里
res.end();
})
server.listen(4000);
console.log('started on port 4000');
- json
var http = require('http');
var onRequest = function (req, res) {
console.log('Request received');
res.writeHead(200, { 'Content-Type': 'application/json' });//类型指定为json
var myObj = { name: 'dry', gender: 'male', hobbdy: 'code' };
res.end(JSON.stringify(myObj));//序列化为json传入
}
var server = http.createServer(onRequest);
server.listen(3000);
console.log('Server started on 3000');
对象序列化为json用JSON.stringify()，反序列化为对象用JSON.parse()。
- html/plain
var http = require('http');
var fs = require('fs');
var onRequest = function (req, res) {
res.writeHead(200, { 'Content-Type': 'text/palin' });//plain替换为html则会将html文本解析渲染出来
//使用管道直接将test.html内容输入到浏览器中
var myRS = fs.createReadStream(__dirname + '/test.html', 'utf8');
myRS.pipe(res);
//直接输入到浏览器
// var html = `<div>you silly b</div>`
// res.end(html);
}
var server = http.createServer(onRequest);
server.listen(5000);
console.log('server started on localhost:5000');