Node.js学习（Node.js基础）

 

 

1、开发环境搭建

v8引擎是作为解析JavaScript程序来运行的

nodejs是一个高性能的，第一个体现在他的JavaScript解析速度很快，v8引擎性能很高，第二个事件驱动和非阻塞

2、全局对象

window对象等等

计时器对象

setTimeout(() => {
    console.log("3 secends passed!");
}, 3000);
// 一次间隔
time = 0;
var timer = setInterval(() => {
    time+=2;
    console.log("2 secends passed");
    if(time > 6){
        clearInterval(timer);
    }
}, 2000);

当前路径、当前文件名字

console.log(__dirname);
/* 打印出当前所在的目录 */
console.log(__filename);
/* 输出当前文件所在目录+名字 */

 

3、回调函数

 函数定义

function sayHi(){
    console.log("hi");
}
var sayBye = function(){
    console.log("bye");
}
sayHi();
sayBye();
// 这两种效果是一样的

回调函数：

function sayHi(){
    console.log("hi");
}
function callBackFunction(fun){
    fun();
}
callBackFunction(sayHi);

 带参数的

function sayHi(name=""){
    console.log("hi" + name);
}
function callFunction(fun,name=""){
    fun(name);
}
callFunction(sayHi);
callFunction(sayHi,"linlinlin");

还可以将函数放在参数中写

function callFunction(fun,name){
    fun(name);
}
callFunction(function(name){
    console.log("hi" + name);
},"linlinlin");

 4、模块

第一种方法：

app.js

var stuff = require('./count');

console.log(stuff.counter(['ruby', 'node.js','react']));
console.log(stuff.adder(3,2));
console.log(stuff.pi);

count.js

var counter = function(arr){
    return "There are" + arr.length + "elements in the array";
}

var adder = function(a, b){
    return `the sum of the 2 numbers is ${a+b}`;
}

var pi = 3.14;

module.exports.counter = counter;
module.exports.adder = adder;
module.exports.pi = pi;

第二种方法：

var counter = function(arr){
    return "There are" + arr.length + "elements in the array";
}

var adder = function(a, b){
    return `the sum of the 2 numbers is ${a+b}`;
}

var pi = 3.14;

module.exports = {
    counter: counter,
    adder: adder,
    pi: pi
}

第二种方法的变种：

var pi = 3.14;

module.exports = {
    counter: function(arr){
        return "There are" + arr.length + "elements in the array";
    },
    adder: function(a, b){
        return `the sum of the 2 numbers is ${a+b}`;
    },
    pi: pi
}

 5、事件

（Node.js里面也有很多函数，就像jQuery中有很多函数一样，需要自己查阅API学习）

events事件：

var events = require('events');

var myEmitter = new events.EventEmitter();

myEmitter.on('myEventName', function(message){
    console.log(message);
});

myEmitter.emit('myEventName', 'my event was emitted!');

events和util是Node.js的核心库

var events = require('events');
var util = require('util');

var Person = function(name){
    this.name = name;
}

util.inherits(Person, events.EventEmitter);
/* Person类继承了events.EventEmitter的特性，可以使用它的方法了 */

var xiaoming = new Person('xiaoming');
var lili = new Person('lili');
var lucy = new Person('Lucy');

var person = [xiaoming,lili,lucy];

person.forEach(function(person){
    person.on('speak',function(message){
        console.log(person.name + " said: " + message);
    })
});
xiaoming.emit('speak', 'hi');
lucy.emit('speak', 'i want a curry!');

 6、读写文件

Node.js在执行JavaScript的时候是单线程的，但是Node.js并不是单线程的

同步读取：

var fs = require('fs');

var readMe = fs.readFileSync("readMe.txt", "utf8");/* 同步读取，执行完这一句再执行下一句语句 */

//fs.writeFileSync("writeMe.txt",readMe);

console.log(readMe);

console.log("finished");

 

异步读取：

var fs = require('fs');

var readMe = fs.readFile("readMe.txt", "utf8",function(err, data){
    console.log(data);
});
/* 异步读取，执行完这一句再执行下一句语句 */
/* 异步方法，异步事件， 异步I/O操作*/
/* 事件队列，在到第二行的时候注册一个事件，告诉队列要读一个事件，这个回调函数在现在喊没有被执行，当在主线程空闲的时候他就会找事件队列中的事件，把他取出来，再从线程池中发起一个线程执行个事件队列里面的事件 */
console.log("finished");

 

异步写文件：

var fs = require('fs');

var readMe = fs.readFile("readMe.txt", "utf8",function(err, data){
    fs.writeFile('writeMe.txt',data, function(){
        console.log('writeMe has finished');
    })
});
console.log("finished");

 8、流

读文件：

var fs = require('fs');
var myReadStream = fs.createReadStream(__dirname + '/readMe.txt', 'utf8');

myReadStream.on('data', function(chunk){
    console.log('new chunk received');
    console.log(chunk);
})
/* <Buffer 0d 0a 3c 21 64 6f 63 74 79 70 65 20 68 74 6d 6c 3e 0d 0a 3c 68 74 6d 6c 3e 0d 0a 3c 68 65 61 64
3e 0d 0a 09 3c 6d 65 74 61 20 63 68 61 72 73 65 74 3d ... >
new chunk received
<Buffer 20 20 20 20 20 20 20 3c 62 75 74 74 6f 6e 20 63 6c 61 73 73 3d 22 62 74 6e 20 62 74 6e 2d 73 6d
20 62 74 6e 2d 6c 69 6e 6b 20 62 74 6e 2d 69 63 6f 6e ... > 
缓冲区文本越多buffer越长(没加编码就这样，要在后面加个编码才能够正常显示)
对文件分段处理
*/

*****

var fs = require('fs');
var myReadStream = fs.createReadStream(__dirname + '/readMe.txt');

myReadStream.setEncoding('utf8');

var data111 = "";
myReadStream.on('data', function(chunk){
    data111 += chunk;
})
/* data是一个事件类型，end也是一个事件类型，data是读取数据的事件，end是读取文件结束的事件 */
myReadStream.on('end', function(){
    console.log(data111);
})

 

写文件：

var fs = require('fs');
var myReadStream = fs.createReadStream(__dirname + '/readMe.txt');
var myWriteStream = fs.createWriteStream(__dirname + '/writeMe.txt');
myReadStream.setEncoding('utf8');

var data111 = "";
myReadStream.on('data', function(chunk){
    // data111 += chunk;
    myWriteStream.write(chunk);
})
/* data是一个事件类型，end也是一个事件类型，data是读取数据的事件，end是读取文件结束的事件 */
myReadStream.on('end', function(){
    // console.log(data111);
})

*****

var fs = require('fs');
var myReadStream = fs.createReadStream(__dirname + '/readMe.txt');
var myWriteStream = fs.createWriteStream(__dirname + '/writeMe.txt');

var writeData = "hello world";
myWriteStream.write(writeData,'utf8');/* 这个地方的编码可以不写！！！ */
myWriteStream.end();
myWriteStream.on('finish',function(){
    console.log('finished');
})

 

这里对流是同步还是异步做个检测：

var fs = require('fs');
var myReadStream = fs.createReadStream(__dirname + '/readMe.txt');
var myWriteStream = fs.createWriteStream(__dirname + '/writeMe.txt');
myReadStream.setEncoding('utf8');

var data111 = "";
myReadStream.on('data', function(chunk){
    // data111 += chunk;
    myWriteStream.write(chunk);
    console.log("结束写文件");
    // 这里是分多次写的，看你文件的大小了
})
/* data是一个事件类型，end也是一个事件类型，data是读取数据的事件，end是读取文件结束的事件 */
myReadStream.on('end', function(){
    // console.log(data111);
    console.log("结束读文件");
    // 结束读文件是在最后进行的
})

console.log("看看是同步还是异步");
// 从这里就可以看出流也是异步进行的

View Code