nodejs汇总

一.node中的模块引入

1.模块的基本导入导出

//one.js
//导出模块方式1
module.exports ={
    a:10,
    b:20,
    c:function(){
        console.log('我是c函数')
    }
}

//index.js
//引入模块: 注意要带./因为是服务器运行了
var one = require('./one');
console.log(one);
console.log(one.a);
console.log(one.b);
one.c();
console.log('----------');

2.四种模块导出写法

//1.综合写法
module.exports ={
    a:10,
    b:20,
    c:function(){
        console.log('我是c函数')
    }
}

//2.单独写法
module.exports.a = 10;
module.exports.b = 20;
module.exports.c = function(){
    console.log('c函数');
}

// 3.拆分写法
var a = 10;
var b = 20;
var c = function(){
    console.log('我是c函数');
}
module.exports={
    a,b,c
}

//4.exports简写
exports.a = 10;
exports.b = 20;
exports.c = function(){
    console.log('c函数')
}

//注意: exports不能直接导出对象, 拿不到对象的值
exports跟module.exports是指向同一个对象,
//这种写法是错误的    
exports ={
    a:10,
    b:20,
    c:function(){
        console.log('我是c函数')
    }
}

3.module.exports 和exports的关系

为了方便，Node为每个模块提供一个exports变量，指向module.exports。这等同在每个模块头部，有一行这样的命令。

var exports = module.exports;

其结果是，在对外输出模块接口时，我们可以直接在 exports 对象上添加方法， 如同在module.exports上添加一样。

注意：因为 Node 模块是通过 module.exports 导出的，如果直接将exports变量指向一个值，就切断了exports与module.exports的联系，导致意外发生。

var exports = module.exports;

//两个是相等的关系，但又不是绝对相当的关系
/*
例如：
1.module.exports可以直接导出一个匿名函数或者一个值
*/
module.exports=function(){
  var a="Hello World"  
  return   a;
}
//但是exports是不可以的，因为这样等于切断了exports与module.exports的联系，exports不再指向module.exports了。

参考文档: module.exports与exports,export与export default之间的关系和区别

4.require引入包的顺序

require('./one')
1.内置模块(node的)
2.文件模块(插件当前文件)
3.文件目录模块(没有对应的文件,就找对象的目录)
4.node_modules模块(先本地,后全局)

更多参考：CommonJS规范

二.nodemon热重载工具

nodemon 也是热部署工具
作用: 自动检测程序的变化，不需要你自己每次修改一点就重启服务器
npm i nodemon -g
nodemon js文件

不需要重启服务器,直接刷新网页就可以了

三.http模块

注意: http模块是node自带的模块，不需要下载，直接引用就可以了
http模块是用来创建服务器的

http.createServer(function(req,res){})  //http模块的createServer方法,会返回一个服务器对象
server.listen(端口);    //服务器对象,调用listen方法来监听端口
res.writeHead(200,{"Content-Type":"text/html;charset=UTF-8"}); //响应头
res.write();  //返回数据内容,也必须使用res.end结束,不然一直请求
res.end();   //结束返回(可以包含res.write)----建议使用

req.url     //可以获得用户请求的网址路径
req.method  //获得用户请求的方法

node的http模块主要使用来创建服务器的.
1. 引入http模块
2. 创建服务器(req和res表示请求和响应对象)
3. 监听端口

//注意: 端口一般大于3000就可以,系统用了一部分,只要不冲突就行了

//1.引入模块
const http  = require('http');
//2.创建服务器,接收请求和响应
let server = http.createServer(function(req,res){    
    res.writeHead(200, { "Content-Type": "text/html;charset=UTF-8" })
    // res.end('返回的内容')
    res.write('返回的内容')
    res.end();
})
//3.监听端口
server.listen(3000,function(){
    console.log('服务器已经开启');
});

//注意,修改服务器代码之后,一定要重启服务器,才能生效
//注意: req.url可以拿到用户请求的网址
//注意:res.end() 相当于: res.write()和res.end();
res.write()写入数据，多个会连接成一个

1.url模块

//url模块用来将请求地址,转换为对象
    url.parse(路径,参数是否为对象);  //默认为false字符串,一般设置为true对象

例如:http://127.0.0.1:3000/login?username=zhangsan&password=123456
//true表示返回一个对象,false表示还是一个字符串, 返回一个对象,其中query中放着参数
let urlObj=url.parse(请求路径,true);   //将参数包装成对象,第二个参数为ture,参数变为对象
urlObj.query.username  //获得用户名
urlObj.query.password  //获得密码 


//参考代码
const http = require('http');
const url = require('url')
let server = http.createServer(function(req,res){
    //设置响应格式
    res.writeHead(200, { "Content-Type": "text/html;charset=UTF-8" })
    if(req.url == '/favicon.ico') return;
    //将url请求字符串,转换为对象
    console.log(req.url);
    //将网址转换为对象
    var urlObj = url.parse(req.url,true);
    console.log(urlObj.query.username)
    res.end('返回的数据');
})

server.listen(3000,function(){
    console.log('服务器启动了');
})

注意：每次修改服务器内容代码，就需要重启

2.node处理get请求

get 请求的参数在网址中: http://127.0.0.1:3000/login?username=zhangsan&password=123456

const http = require('http');
const url = require('url');
let server = http.createServer(function(req,res){
    res.writeHead(200, { "Content-Type": "text/html;charset=UTF-8" });
    if(req.url == '/favicon.ico') return;
    console.log(req.url);
    //将请求参数转换为对象
    let params = url.parse(req.url,true);
    //得到参数对象
    console.log(params.query);
    res.end('得到数据了'+req.url);
})

server.listen(3000,function(){
    console.log('服务器启动了');
})

3.node处理post请求

//post请求的数据,在请求体中,需要以文件块的方式进行接收

//获得请求数据,chunk就是一块块数据,然后拼接在一起
req.on('data',function(chunk){

})
//数据获取结束
req.on('end',function(){
    //获取数据结束后,使用res.end的打印
})

// 使用postman模拟发送post数据并且,写在body中
const http = require('http');

let server = http.createServer(function(req,res){    
    //判断是否是post请求
    if(req.method === 'POST'){        
        //定义变量存储数据
        let postData = '';
        //接收数据
        req.on('data',function(chunk){
            //将二进制转换为字符串
            postData += chunk;
        })
        //接收数据完毕
        req.on('end',function(){                      
            //直接输出,不识别中文
            console.log(postData);           
            res.end(postData);            
        })
    }
})
server.listen(3000,function(){
    console.log('服务器运行了')
})

注意: 对象转换为字符串的方法: util.inspect() 或者 JSON.stringify()

querystring.parse() 将字符串转换为对象

4.node返回JSON数据

// 根据请求，返回JSON数据。写死一个对象，然后转为JSON字符串，返回就行了 
JSON.stringify()

const http = require('http');
let server = http.createServer(function(req,res){    
    res.writeHead(200, { "Content-Type": "text/json;charset=UTF-8" });
    let user = {
        name:'张三',
        age:19
    }

    res.end(JSON.stringify(user));
})
server.listen(3000,function(){
    console.log('服务器运行了')
})

四.fs模块

fs.stat  检测是文件还是目录
fs.mkdir  创建目录
fs.writeFile  创建写入文件
fs.appendFile  追加文件
fs.readFile   读取文件
fs.readdir    读取目录
fs.rename    重命名
fs.rmdir     删除目录
fs.unlink    删除文件
fs.createReadStream  从文件流中读取数据
fs.createWriteStream 写入文件流数据
管道流概念: 实现大文件传输(小文件一次性传输过去,大文件慢慢传)

1.创建文件夹

const fs = require('fs');
//第一个参数,文件夹路径和名字, 第二个参数是权限默认就可以,不写,第三个参数是错误的回调
fs.mkdir('demo', function(err) {
    if (err) {
        console.log('文件夹创建失败');
        console.log(err);
        //创建文件失败后,就不继续打印创建成功了
        return false;
    }
    console.log('创建文件夹成功');
})

//注意: 如果demo/a 就可以创建两个文件夹 demo下有个a

2.检测文件和目录

const fs = require('fs');
//err错误信息, stats检测对象,然后可以调用
//isFile() 判断是否是文件,返回布尔类型
//isDirectory() 判断是文件夹,返回布尔类型
fs.stat('demo', function(err, stats) {
    if (err) {
        console.log('文件检测错误');
        console.log(err);
        return false;
    }
    console.log('文件:' + stats.isFile());
    console.log('文件夹:' + stats.isDirectory());
})

3.删除目录

const fs = require('fs');

fs.rmdir('demo', function(err) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log('删除目录成功');
})

4.读取目录

//fs.readdir 读取目录:  会将目录下的文件和文件夹都获取到
let fs = require('fs');

//拿到一个文件夹下的所有目录: 包括文件夹和文件
fs.readdir('demo', function(err, data) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log(data);
})

5.创建文件

//创建文件,并写入内容
let fs = require('fs');

//第一个参数: 文件名字,没有这个文件创建,有文件覆盖
//第二个参数: 文件内容
//第三个参数: 文件编码格式
//第四个参数:错误的回调
fs.writeFile('a.txt', '用node创建的文件111', 'utf-8', function(err) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log('写入成功');
})

6.追加文件内容

let fs = require('fs');

//第一个参数: 文件名字,没有这个文件创建,有文件覆盖
//第二个参数: 文件内容
//第三个参数: 文件编码格式
//第四个参数:错误的回调
fs.appendFile('a.txt', '111这是追加的内容', function(err) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log('追加成功');
})

7.读取文件

let fs = require('fs');

//第一个参数: 文件名字,没有这个文件创建,有文件覆盖
//第二个参数:错误的回调
fs.readFile('a.txt', function(err, data) {
    if (err) {
        console.log(err);
        return false;
    }
    //默认读取格式为16进制 Buffer
    console.log(data);
    console.log(data.toString());
})

8.删除文件

let fs = require('fs');

fs.unlink('a.1.txt', function(err) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log('删除文件成功');
})

9.重命名

let fs = require('fs');

//修改文件的名字
// fs.rename('c.html', 'x.html', function(err) {

//     if (err) {
//         console.log(err);

//         return false;
//     }
//     console.log('修改名字成功');
// })

//也可以修改文件夹名字
// 还可以进行剪切,文件夹必须存在
fs.rename('demo/b/1.txt', './1.txt', function(err) {

    if (err) {
        console.log(err);
        return false;
    }
    console.log('修改名字成功');
})

10.读取流

1.创建读取流
let readStream = fs.createReadStream('mi.jpg');
2.接收数据的回调 readStream.on('data',function(err){})
3.数据接收完毕的回调
4.错误信息的回调

//图片读取的很慢,文字读取的很快

const fs = require('fs');

//创建读取流,读取a.txt文件
let readStream = fs.createReadStream('mi.jpg');

//定义一个空字符串,用于拼接数据
let str = '';
//记录读取次数
let count = 0;

//开始读取数据
//data就是数据事件,chunk是每个数据的分片
//count表示读取多少次
readStream.on('data', function(chunk) {
    str += chunk;
    count++;
})

//读取完毕后
readStream.on('end', function(chunk) {
    console.log(count);
    // console.log(str);
})

//读取失败的处理
readStream.on('error', function(err) {
    console.log(err);
})

11.写入流

1.创建写入流,会创建某个文件
    let writeStream = fs.createWriteStream('str.txt');
2.写入文件,并结束
    writeStream.write(str,'utf-8');
    writeStream.end();
3.写入结束事件
    writeStream.on('finish',function(){
        console.log('写入完成');
    })

const fs = require('fs');

let str = "我是从数据库获取的数据";

//创建写入流
let writeStream = fs.createWriteStream('str.txt');

//循环写入100句这个内容
for (let i = 0; i < 100; i++) {
    writeStream.write(str, 'utf-8');
}
//标记写入完成
writeStream.end();

//写入完成的事件
writeStream.on('finish', function() {
    console.log('写入完成');
})

//写入失败的事件
writeStream.on('error', function() {
    console.log('写入失败');
})

12.管道流

文件读取: 适合小文件,直接先将文件读入内存中,然后再存起来
管道流读取: 适合大文件进行拷贝,传输,将文件分片,慢慢传输.(读取流,写入流,管道流)

fs.createReadStream()  读取文件流
fs.createWriteStream() 写入文件流

http://www.zymseo.com/node/434.html

const fs = require('fs');

//创建一个读取流
let readStream = fs.createReadStream('snow.mp3');

//创建一个写入流
let writeStream = fs.createWriteStream('mysnow.mp3');

//管道读写操作,读取snow.mp3到新创建的mysnow.mp3,实现文件拷贝

readStream.pipe(writeStream);

五.path模块

path模块提供了一些方法,用来解决路径拼接的问题(可以简单理解为字符串拼接)

路径拼接: path.join(路径1,路径2)  拼接两个路径
路径获取:  path.resolve()   返回当前目录的绝对路径

获取路径：path.dirname(filepath)
获取文件名：path.basename(filename)
获取扩展名：path.extname(filepath)

//重点掌握: path.join() 和path.resovle()
//https://blog.csdn.net/NextStand/article/details/59535555

const path = require('path');

var str = path.join('demo','test');
console.log(str);

//返回当前目录的全局路径
var a = path.resolve();
console.log('本地路径'+a);

//获得当前的文件夹名字
var b = path.dirname('demo/a.txt');
console.log(b);

//获取文件名
var c = path.basename('demo/a.txt')
console.log(c);

// 获取文件的后缀名
var d = path.extname('demo/a.txt');
console.log(d);

六.全局对象模块

__filename 表示当前正在执行的脚本的文件名
__dirname 表示当前执行脚本所在的目录。

//单次和多次定时
setTimeout(cb, ms)
clearTimeout(t)
setInterval(cb, ms)
clearInterval(t)

七.node中常见模块的总结

1.npm的常见命令使用
2.node的模块引入(4种,1个注意点)
3. node中的常用模块
    http模块
    url模块
    fs文件模块
    path 路径模块
    global 全局模块    
node是别人在js的基础上重新开发了一套api和解析器, 这样js代码就具备了上面的这些功能.但是用这些功能我们能做出东西,但是效率很低,所以有了其他的框架; 目前前端中的node开发框架有: express < koa < egg

八.node中操作mysql数据库

学mysql这种类型的第三方包,主要是看文档,能够正确的实现功能就可以了.不需要自己独立背下来.
1.下载mysql包,并引入
2. 创建连接 mysql.createConnection(数据库参数对象)---得到连接
3. 开始连接  conn.connect();
4.查询数据库 conn.query(sql语句,参数数组,回调函数)
5.结束连接  conn.end();

1.查询数据

const mysql = require('mysql');
//1.创建数据库连接
const conn =mysql.createConnection({
    host: '127.0.0.1',
    user: 'root',
    password: '',
    database: 'qd01',
    port: '3306'
})
// 2.开始连接
conn.connect();
// 3.查询语句
let sql = 'select * from user';
conn.query(sql,function(err,rows){
    if(err) throw err;
    console.log(rows);
})

//4.结束连接
conn.end();

//返回错误的两种写法,如果数据库错误,就会报错
  if(err){
      console.log(err);
      return false;
  }
//简易写法
    if(err) throw err;

2.添加数据

1.sql中使用?当占位符
2.conn.query(sql语句,参数数组,function(err,result){})
3.affectedRows受影响行数

const mysql = require('mysql');
//1.创建数据库连接
const conn =mysql.createConnection({
    host: '127.0.0.1',
    user: 'root',
    password: '',
    database: 'qd01',
    port: '3306'
})
// 2.开始连接
conn.connect();
// 3.查询语句
let sql = 'insert into user(name,age,sex,tel) values(?,?,?,?)';
let params = ['任正非',29,1,'111111'];
conn.query(sql,params,function(err,result){  
    if(err) throw err;
    console.log(result);
    if(result.affectedRows>0){
        console.log('插入成功')
    }else{
        console.log('插入失败');
    }
})
//4.结束连接
conn.end();

3.删除数据

//删除,如果只有一个参数,就直接写,不用当数组
let sql = 'delete from user where id=?';
let params = 13;
conn.query(sql,params,function(err,result){  
    if(err) throw err;
    console.log(result);
    if(result.affectedRows>0){
        console.log('删除成功')
    }else{
        console.log('删除失败');
    }
})

4.修改数据

//修改
let sql = 'update user set name =? where id=?';
let params = ['曹操111',12];
conn.query(sql,params,function(err,result){  
    if(err) throw err;
    console.log(result);
    if(result.affectedRows>0){
        console.log('修改成功')
    }else{
        console.log('修改失败');
    }
})

5.数据库连接池

1.创建连接池对象mysql.createPool(配置)
2.从连接池中获得数据库连接对象  pool.getConnection()
3.查询数据库 conn.query(sql语句,参数,回调)
4.释放连接 conn.release();

query(sql语句,参数,回调函数)
参数的写法: 一个值,直接写
        多个值用数组[参数1,参数2]
        如果插入的数据有多个,可以用对象,但是insert语句的写法就要修改
        insert into users set ?
        后面就可以写对象

const mysql = require('mysql');

const dbconfig = {
    host: '127.0.0.1',
    user: 'root',
    password: '',
    database: 'qd01',
    port: '3306'
}

//1.创建数据库连接池对象
const pool = mysql.createPool(dbconfig);

let sql = 'select * from user';
//获得连接对象
pool.getConnection(function(err,conn){
    //查询数据
    conn.query(sql,function(err,rows){
        console.log(rows);
        //释放连接
        conn.release();
    })
})

6.数据库返回到页面

const http = require('http');
const mysql = require('mysql');

//创建服务器
let server = http.createServer(function(req,res){  
    res.end(JSON.stringify(userDate));      
})

server.listen(3000,function(){
    console.log('服务器启动了')
})

let userDate = '空数据';
//数据库相关的操作
const dbconfig = {
    host: '127.0.0.1',
    user: 'root',
    password: '',
    database: 'qd01',
    port: '3306'
}

//1.创建数据库连接池对象
const pool = mysql.createPool(dbconfig);
let sql = 'select * from user';
//获得连接对象
pool.getConnection(function(err,conn){
    //查询数据
    conn.query(sql,function(err,rows){
        userDate=rows;
        console.log(rows);
        //释放连接
        conn.release();
    })
})

九.Node多进程

我们都知道 Node.js 是以单线程的模式运行的，但它使用的是事件驱动来处理并发，这样有助于我们在多核 cpu 的系统上创建多个子进程，从而提高性能。

每个子进程总是带有三个流对象：child.stdin, child.stdout 和child.stderr。他们可能会共享父进程的 stdio 流，或者也可以是独立的被导流的流对象。

Node 提供了 child_process 模块来创建子进程，方法有：

• exec - child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。
• spawn - child_process.spawn 使用指定的命令行参数创建新进程。
• fork - child_process.fork 是 spawn()的特殊形式，用于在子进程中运行的模块，如 fork(‘./son.js’) 相当于 spawn(‘node’, [‘./son.js’]) 。与spawn方法不同的是，fork会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信。

1.exec() 方法

child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。

语法如下所示：

child_process.exec(command[, options], callback)

参数

参数说明如下：

command： 字符串， 将要运行的命令，参数使用空格隔开

options ：对象，可以是：

• cwd ，字符串，子进程的当前工作目录
• env，对象 环境变量键值对
• encoding ，字符串，字符编码（默认： ‘utf8’）
• shell ，字符串，将要执行命令的 Shell（默认: 在 UNIX 中为/bin/sh， 在 Windows 中为cmd.exe， Shell 应当能识别 -c开关在 UNIX 中，或 /s /c 在 Windows 中。 在Windows 中，命令行解析应当能兼容cmd.exe）
• timeout，数字，超时时间（默认： 0）
• maxBuffer，数字， 在 stdout 或 stderr 中允许存在的最大缓冲（二进制），如果超出那么子进程将会被杀死 （默认: 200*1024）
• killSignal ，字符串，结束信号（默认：’SIGTERM’）
• uid，数字，设置用户进程的 ID
• gid，数字，设置进程组的 ID

callback ：回调函数，包含三个参数error, stdout 和 stderr。

exec() 方法返回最大的缓冲区，并等待进程结束，一次性返回缓冲区的内容。

//support.js 文件代码：
console.log("进程 " + process.argv[2] + " 执行。" );


//master.js 文件代码：
const fs = require('fs');
const child_process = require('child_process');

for(var i=0; i<3; i++) {
    var workerProcess = child_process.exec('node support.js '+i, function (error, stdout, stderr) {
        if (error) {
            console.log(error.stack);
            console.log('Error code: '+error.code);
            console.log('Signal received: '+error.signal);
        }
        console.log('stdout: ' + stdout);
        console.log('stderr: ' + stderr);
    });

    workerProcess.on('exit', function (code) {
        console.log('子进程已退出，退出码 '+code);
    });
}

执行以上代码，输出结果为：

$ node master.js 
子进程已退出，退出码 0
stdout: 进程 1 执行。

stderr: 
子进程已退出，退出码 0
stdout: 进程 0 执行。

stderr: 
子进程已退出，退出码 0
stdout: 进程 2 执行。

stderr: 

2.spawn() 方法

child_process.spawn 使用指定的命令行参数创建新进程，语法格式如下：

child_process.spawn(command[, args][, options])

参数

参数说明如下：

command： 将要运行的命令

args： Array 字符串参数数组

options Object

• cwd String 子进程的当前工作目录
• env Object 环境变量键值对
• stdio Array|String 子进程的 stdio 配置
• detached Boolean 这个子进程将会变成进程组的领导
• uid Number 设置用户进程的 ID
• gid Number 设置进程组的 ID

spawn() 方法返回流 (stdout & stderr)，在进程返回大量数据时使用。进程一旦开始执行时 spawn() 就开始接收响应。

// support.js 文件代码：
console.log("进程 " + process.argv[2] + " 执行。" );

// master.js 文件代码：
const fs = require('fs');
const child_process = require('child_process');

for(var i=0; i<3; i++) {
    var workerProcess = child_process.spawn('node', ['support.js', i]);

    workerProcess.stdout.on('data', function (data) {
        console.log('stdout: ' + data);
    });

    workerProcess.stderr.on('data', function (data) {
        console.log('stderr: ' + data);
    });

    workerProcess.on('close', function (code) {
        console.log('子进程已退出，退出码 '+code);
    });
}

执行以上代码，输出结果为：

$ node master.js stdout: 进程 0 执行。

子进程已退出，退出码 0
stdout: 进程 1 执行。

子进程已退出，退出码 0
stdout: 进程 2 执行。

子进程已退出，退出码 0

3.fork 方法

child_process.fork 是 spawn() 方法的特殊形式，用于创建进程，语法格式如下：

child_process.fork(modulePath[, args][, options])

参数

参数说明如下：

modulePath： String，将要在子进程中运行的模块

args： Array 字符串参数数组

options：Object

• cwd String 子进程的当前工作目录
• env Object 环境变量键值对
• execPath String 创建子进程的可执行文件
• execArgv Array 子进程的可执行文件的字符串参数数组（默认： process.execArgv）
• silent Boolean 如果为true，子进程的stdin，stdout和stderr将会被关联至父进程，否则，它们将会从父进程中继承。（默认为：false）
• uid Number 设置用户进程的 ID
• gid Number 设置进程组的 ID

返回的对象除了拥有ChildProcess实例的所有方法，还有一个内建的通信信道。

// support.js 文件代码：
console.log("进程 " + process.argv[2] + " 执行。" );

// master.js 文件代码：
const fs = require('fs');
const child_process = require('child_process');

for(var i=0; i<3; i++) {
    var worker_process = child_process.fork("support.js", [i]);    

    worker_process.on('close', function (code) {
        console.log('子进程已退出，退出码 ' + code);
    });
    }

执行以上代码，输出结果为：

$ node master.js 
进程 0 执行。
子进程已退出，退出码 0
进程 1 执行。
子进程已退出，退出码 0
进程 2 执行。
子进程已退出，退出码 0

十.node的知识总结

1.npm的常见命令
    npm i  包名 -g      全局安装
    npm i 包名 -S       项目依赖
    npm i 包名 -D       开发依赖

2.模块的导入导出
//a.js
module.exports = {//对象和方法}

//index.js
var m = require('./a.js');
console.log(m.name);
m.run();

3.热重载工具
    nodemon

4.http模块
    http.createServer(function(req,res){})  //http模块的createServer方法,会返回一个服务器对象
    server.listen(端口);    //服务器对象,调用listen方法来监听端口
    res.writeHead(200,{"Content-Type":"text/html;charset=UTF-8"}); //响应头
    res.write();  //返回数据内容
    res.end();   //结束返回(可以包含res.write)----建议使用

    req.url     //可以获得用户请求的网址路径

5.url模块
    let urlObj=url.parse(请求路径,true);   //将参数包装成对象
    urlObj.query.username  //获得用户名
    urlObj.query.password  //获得密码 

6.fs模块
    fs.stat  检测是文件还是目录
    fs.mkdir  创建目录
    fs.writeFile  创建写入文件
    fs.appendFile  追加文件
    fs.readFile   读取文件
    fs.readdir    读取目录
    fs.rename    重命名
    fs.rmdir     删除目录
    fs.unlink    删除文件
    fs.createReadStream  从文件流中读取数据
    fs.createWriteStream 写入文件流数据
    管道流概念: 实现大文件传输(小文件一次性传输过去,大文件慢慢传)

7.path模块
    路径拼接: path.join(路径1,路径2)  拼接两个路径
    路径获取:  path.resolve()   返回当前目录的绝对路径
    获取路径：path.dirname(filepath)
    获取文件名：path.basename(filename)
    获取扩展名：path.extname(filepath)
8.全局模块
    __filename 表示当前正在执行的脚本的文件名
    __dirname 表示当前执行脚本所在的目录。

9.node操作数据库
    1.创建连接
    2.开始连接
    3.查询数据库
    4.关闭连接