NodeJs基础

NodeJs基础

概念

它是一个运行在服务端的JavaScirpt平台，基于Chrome浏览器在运行时创建的一个平台,基于Chrome浏览器在运行时创建的一个平台,基于google的v8引擎的，速度非常的快，性能好,它可以处理大量的并发。nodeJs可以接收好几种文件类型,nodeJs，它可以提供http服务，IIS、Apache类似，都是http的服务,node需要手动的进行一些配置

dos命令

​ --cls，清空控制台屏幕

​ --dir，列出当前目录中的文件和目录

事件机制

nodeJs当中，基本上所有的事件机制，都是基于观察者模式。

在JavaScript当中存在着一个事件队列，这个东西只是在内存当中的，看不到，操作不了，nodeJs在异步操作的完成的时候，会发一个事件，到事件队列。当请求完成时，会把结果返回给用户。

Node模块

-----核心模块, nodeJs内置的；

​ 核心模块在运行的时候，被编译为二进制的流了，

----自定义的模块…

nodeJs要做一些工作，都需要加载各种模块

​ 这个在运行的时候，有一个编译、寻址的过程， 所以它的速度，会比核心模块慢。

http模块

它要创建http服务也是一样，它需要http模块。

require 指令，它用来载入各种模块；

使用 http.createServer()，创建服务

.listen()，监听服务的端口号，但是一般不要使用 8080，因为许多其它的服务都会默认使用它

发送http请求,就是访问某个网址,本地服务器地址：http://localhost:端口号或者http://127.0.0.1:5874

端口号:四位数字,

,ctrl + c，快速的停止node的服务

Content-Type

​ text/plain，纯文本；

​ text/html，html的文本；

// 第一个http模块
// 引入http模块
var http1 = require('http');
// console.log(http);
// 调用createServer方法,传入一个匿名函数,参数为request,response
// 调用listen方法 监听服务的端口号(四位数字))
http1.createServer(function(request, response) {
    //发送头部信息,状态码为200
    //内容的类型 纯文本text/plain   html文本: text/html
    //  调用writeHead方法
    response.writeHead(200, { 'Content-Type': 'text/html;charset=utf8' });
    // 向客户端(浏览器)发送数据
    response.end('
第一个服务
');
}).listen(8888);
console.log('8888,server is running');

fs模块

fs模块，nodeJs的文件系统，fileSystem

// fs模块
var fs = require('fs');
// 这里是异步输出的,通过回调函数
fs.readFile('file.txt', function(err, _data) {
    console.log(_data.toString());
})
console.log('程序结束了,这里是异步输出的');

综合写法

var http1 = require('http');
var fs = require('fs');
http1.createServer(function(request, response) {
    response.writeHead(200, { 'Content-Type': 'text/html;charset=utf8' });
    fs.readFile('file.txt', function(err, _data) {
        response.end(_data.toString());
    })
}).listen(8888);
console.log('8888,server is running');

同步

同步 sync [sɪŋk]，是阻塞的；是按顺序执行的；

异步

nodeJs，它是异步编程。异步编程它就是依托于回调来实现的。nodejs它大量的使用了回调函数，这样在代码执行的时候，就没有阻塞或是等待什么的，提高了效率，可以处理大量的并发请求。

异步，是非阻塞的；是不按顺序执行的。它不用等待，所以提高性能

线程

nodejs它是单线程、单进程的应用程序，

单线程，node的fs模块读取文件，它有同步、异步，同步会有阻塞，那这个阻塞就是单线程

Node事件

在nodeJs当中，所有事件产生的对象，events模块，

在events模块里面有一个对象，events.EventEmitter,EventEmitter的核心，是事件的触发与监听功能的封装。在具体使用的时候，还是require(‘events’)，

on函数，用于绑定事件；

emit，用于触发事件；

// 首先引入evnets模块
var event = require('events');

// 手动生成 event的EventEmitter对象的实例
var emitter = new event.EventEmitter();
// 使用on绑定事件 事件名自定义
emitter.on('aaa', function() {
    console.log('111111')
        //aaa触发后触发ccc
    emitter.emit('ccc'); // 33333
});
emitter.on('bbb', function() {
    console.log('22222222')
        //bbb触发后通过延时器3s后触发ddd事件
    setTimeout(function() {
        emitter.emit('ddd'); // 3s后 444444
    }, 2000)
});
emitter.on('ccc', function() {
    console.log('33333');
    //ccc触发后触发bbb事件
    emitter.emit('bbb'); // 22222222
});
emitter.on('ddd', function() {
    console.log('444444')
});
// _eventsCount: 3,事件的数量
// console.log(emitter);
// 使用emit触发事件 
//先触发aaa
emitter.emit('aaa'); // 111111

Buffer 缓冲区

缓冲区，其实就是内存。JavaScript语言，它本身不能操作内存。js它只有处理字符串类型的数据，它不能处理二进制类型的数据。

nodejs它要响应http的请求，处理tcp的流或是文件流的，必须要使用到二进制的数据，所以在nodeJs当中，就定义了一个Buffer类，它用来创建、操作一个存放二进制数据的缓存区。

随着node核心库一起安装的，所以连require都不用写，

alloc

.alloc，返回一个指定大小的Buffer实例；写入的超出的部分，不显示

.length，返回Buffer缓冲区的大小；

.toString()，读取缓冲区的内容

.write()，向缓冲区中写入内容

/*Buffer缓冲区 不需要require引入,直接使用*/
// console.log(Buffer);
// .alloc设置缓冲区的指定大小,超出部分不显示
var _buf = Buffer.alloc(10);
// .write 向缓冲区写入内容
_buf.write('132...,我是一二三');
// .toString() 读取内容
console.log(_buf.toString());
// .length 缓冲区的数量
console.log(_buf.length);
/*案例 生成26个字母*/
var _buf = Buffer.alloc(26);
// 循环生成字母
// ASCII a的ASCII 97
for (var i = 0; i < 26; i++) {
    _buf[i] = i + 97;
}
console.log(_buf.toString())

Stream，流

node中抽象接口，很多对象都实现了它的功能。

Stream流，有四种类型，

​ -Readable 读，

​ -Writable 写，

​ -Duplex 可读可写，

​ -Transform 被写入之后，读出结果

Stream，同时它也是 EventEmitter 的实例，

​ -data, 有数据可读时

​ -end, 没有更多数据可读时

​ -error, 报错时

​ -finish, 所有数据已经被写入时

/*从流中读取文件*/
// 首先引入fs模块
var fs = require('fs');
var _data = '';
var readStream = fs.createReadStream('readStream.txt');
// 设置编码格式
readStream.setEncoding('utf-8');
//处理事件 on绑定事件,可读流 data 有数据可读时
readStream.on('data', function(_d) {
    // console.log(_d)
    _data += _d;
})
// 没有数据可读时 end
readStream.on('end', function(_d) {
    console.log(_data);
})
// 数据读取错误报错时 error
readStream.on('error', function(err) {
    console.log(err)
})

/* 向流中写入文件*/
var fs = require('fs');
var _data = '这是要被写入的内容';
// 创建写入流
var writeStream = fs.createWriteStream('write_text.txt');
// 设置编码,并写入 .write
writeStream.write(_data, 'utf-8');
// 处理事件 on   finish
writeStream.on('finish', function() {
    console.log('全部数据写入完成');
})
writeStream.on('error', function(err) {
    console.log(err)
});
console.log('写入完成xxx');

管道流

它提供了一个从输出流，到输入流的机制。通常是用于从一个流当中获得数据，并将数据传递到另一个流当中。

// 管道流 输出流到输入流,从一个流获取数据,并将数据传递到另一个流中
var fs = require('fs');
// 创建可读流
var readStream = fs.createReadStream('aaa.txt');
// 创建可写流
//  .pipe()
var writeStream = fs.createWriteStream('bbb.txt');
readStream.pipe(writeStream);
console.log('执行完成');

// 压缩
var fs = require('fs');
// 引入zlib
var zlib = require('zlib');
fs.createReadStream('aaa.txt').pipe(zlib.createGzip()).pipe(fs.createWriteStream('aaa.txt.gz'))
console.log('压缩完成');

// 解压
var fs = require('fs');
var zlib = require('zlib');
fs.createReadStream('aaa.txt.gz').pipe(zlib.createGunzip()).pipe(fs.createWriteStream('ccc.txt'))
console.log('解压完成');

链式流

.pipe()，主要是这个方法，它是一个可以链式操作的方法，也就是说，可以多个.pipe()方法连起来使用。

node的模块系统

node.js在模块这个部分，有二个对象，

​ - exports，导出模块，它是模块对外公开的接口，

​ - require，引入模块，从外部艾玛一个模块的接口,

自定义的模块，要写路径， ./ 是根目录

module，将整个模块，全部导出

// 引入模块 require中写的是路径
var b = require('./b');
var c = require('./c')
var mod = require('./module_obj')
b.xxfn();
c.ccFn('这里是c模块');
// 首先要创建实例
var _m = new mod();
console.log(_m.a);
_m.b('这里是将整个模块全部导出')

/* 1 模块*/
// 创建一个模块,并导出 exports
exports.xxfn = function() {
    console.log('b模块的导出')
}
/*2 模块*/
// 可以传递参数
exports.ccFn = function(_n) {
    console.log(_n)
}
/*3 将整个模块全部导出 module 函数名大写开头 */
function Fnobj() {
    this.a = 123;
    this.b = function(_obj) {
        console.log(_obj)
    }
}
module.exports = Fnobj;

nodeJs的 get

浏览器地址栏的url，就是一个get请求的。https://www.baidu.com/s?ie=UTF-8&wd=baidu

get请求的参数是，url的?号后面的东西?ie=UTF-8&wd=baidu

new URL，用于解析相对、绝对的路径

.searchParams，查询url的参数

Iterator，它不是一种新的数据结构，

js有数组、Object，es6又有了map、set,这么多的数据结构，就需要一种统一的访问机制，这个统一的访问机制，就是Iterator。如果要遍历Iterator，就需要 for of循环，别的不行,如果是Iterator的对象，就需要用for of循环.

// 获取get请求的参数
var http = require('http');
http.createServer(function(req, res) {
    // 在一些情况下,referer有可能没有
    // referer 中的内容(本机) http://127.0.0.1:8888/xx?a=1&b=2&c=3 
    // console.log(req.headers.referer);
    if (req.headers.referer != undefined) {
        // 创建一个URL实例 传递参数req.headers.referer
        var myUrl = new URL(req.headers.referer);
        // console.log(myUrl.searchParams) // 结果URLSearchParams { 'a' => '1', 'b' => '2', 'c' => '3' }
        // Iterator 迭代器 要使用for of 遍历
        // 获取myUrl.searchParams中的键 .keys()
        console.log(myUrl.searchParams.keys()); // URLSearchParams Iterator { 'a', 'b', 'c' }
        var _k = myUrl.searchParams.keys();
        for (var i of _k) {
            console.log(i);
        }
        // 获取myUrl.searchParams中的值 .values()
        console.log(myUrl.searchParams.values()); // URLSearchParams Iterator { '1', '2', '3' }
        var _v = myUrl.searchParams.values();
        for (var i of _v) {
            console.log(i);
        }
        // 返回所有的键值对 .entries()
        console.log(myUrl.searchParams.entries()) //URLSearchParams Iterator { [ 'a', '1' ], [ 'b', '2' ], [ 'c', '3' ] }
        var _e = myUrl.searchParams.entries();
        for (var i of _e) {
            // console.log(i); // [ 'a', '1' ] [ 'b', '2' ] [ 'c', '3' ]
            console.log(i[0] + '/' + i[1]) // 获取了参数的键和值
        }

    }
    res.end();
}).listen(8888, function() {
    console.log('server is running');
})

POST

POST一般通过表单来发起post请求，把表单的数据在后台发送给服务器。

// post请求 post一般通过表单发送请求
// 首先要引入http
var http = require('http');
//  querystring模块，提供用于解析、格式化URL的参数的工具模块
var querystring = require('querystring')
    // 创建html表单
var _htmlText = `


    姓名:
    


    年龄:
    


    


`

http.createServer(function(req, res) {
    // 数据中会出现两个空对象{} {} 是因为req.url中的/favicon.ico导致的，所以开始需要判断
    if (req.url != '/favicon.ico') {
        // 首先设置响应头 状态码+{'Content-Type':'text/html;charset=utf8'}
        res.writeHead(200, { 'Content-Type': 'text/html;charset=utf8' })
            // http是无状态的，传入的是字符
            // req请求，有数据时
        var _data = '';
        req.on('data', function(_d) {
                _data += _d;
            })
            // 没有数据时
        req.on('end', function() {
            // console.log(querystring.parse(_data))
            // [Object: null prototype] 原型没有继承自javascript中的Object
            // 1.通过JSON 中的JSON.stringify() 转变为JSON字符串
            // 2.调用JSON.parse()将JSON字符串格式转变为对象
            var _obj = JSON.stringify(querystring.parse(_data));
            _data = JSON.parse(_obj)
            console.log(_data);
            if (_data.username) {
                res.write(`姓名:${_data.username}
年龄:${_data.age}`)
            } else {
                // 将内容写入
                res.write(_htmlText);
            }
            // 这里的res.end() 要放在内部
            res.end();
        })
    }
}).listen(8888, function() {
    console.log('8888,server is running')
})