NodeJS入门学习教程

1763392456 2021-01-30 我要评论

一、概念

1.什么是nodejs

Node.js是JavaScript 运行时环境，通俗易懂的讲，Node.js是JavaScript的运行平台
Node.js既不是语言，也不是框架，它是一个平台

2.nodejs特点

没有Bom，Dom
在Node中这个JavaScript执行环境为JavaScript提供了一些服务器级别的API
- 例如文件的读写
- 网络服务的构建
- 网络通信
- http服务器
构建在Chrome的V8引擎之上，意味着nodejs的执行效率很高
基于事件驱动envent-driven ，non-blocking I/O mode 非阻塞I/O模型（异步）ightweight and efficent. 轻量和高效
包含NPM包管理器，npm 是世界上最大的开源生态系统，绝大多数JavaScript相关的包都存放在npm上，这样做的目的是为了让开发人员更方便的去下载使用

3.nodejs可以做什么

web服务器后台
命令行工具，执行npm命令等
借助npm包管理器构建项目，和上传自己的组件

二、安装和使用

到官网下载Node，并一路next就能完成安装，如果安装过后再次安装新版本则会自动升级安装。官网：https://nodejs.org/en/

确认是否安装成功，输入以下命令查看版本号：

node --version

配置目录

在nodejs安装目录创建【node_global】及【node_cache】两个文件夹

创建完两个空文件夹之后，打开cmd命令窗口，输入

npm config set prefix "D:\Develop\nodejs\node_global"
npm config set cache "D:\Develop\nodejs\node_cache"

接下来设置环境变量，关闭cmd窗口，“我的电脑”-右键-“属性”-“高级系统设置”-“高级”-“环境变量”

进入环境变量对话框，在【系统变量】下新建【NODE_PATH】，输入【D:\Develop\nodejs\node_global\node_modules】

将【用户变量】下的【Path】修改为【D:\Develop\nodejs\node_global】

三、核心API的使用

Global 全局对象

Global是node.js的全局对象，使用它里面的属性或方法或子对象，可以不用加global

例如

global.console.log('你好');

**另外：**这些对象在所有的模块中都可用。以下的变量虽然看似全局的，但实际上不是。它们仅存在于模块的作用域中

console.log('Dirname:',__dirname);
console.log('Filename:',__filename);
console.log('Exports:',exports);
console.log('Module:',module);
console.log('require:',require);

打印结果：

Dirname: F:\vue_project\learn_nodeJs\src\01-NodeJs初步使用
Filename: F:\vue_project\learn_nodeJs\src\01-NodeJs初步使用\5-全局变量.js
Exports: {}
Module: Module {
  id: '.',
  path: 'F:\\vue_project\\learn_nodeJs\\src\\01-NodeJs初步使用',
  exports: {},
  parent: null,
  filename: 'F:\\vue_project\\learn_nodeJs\\src\\01-NodeJs初步使用\\5-全局变量.js',
  loaded: false,
  children: [],
  paths: [
    'F:\\vue_project\\learn_nodeJs\\src\\01-NodeJs初步使用\\node_modules',
    'F:\\vue_project\\learn_nodeJs\\src\\node_modules',
    'F:\\vue_project\\learn_nodeJs\\node_modules',
    'F:\\vue_project\\node_modules',
    'F:\\node_modules'
  ]
}
require: [Function: require] {
  resolve: [Function: resolve] { paths: [Function: paths] },
  main: ...,//省略内容
  extensions: ...,//省略内容
  cache: ...,//省略内容
}

1.fs模块的使用

浏览器中的JavaScript是没有文件操作能力的，但是Node中的JavaScript具有文件操作能力，在Node中如果想要进行文件的操作就必须引用fs这个核心模块。fs模块提供了了所有文件操作相关的API

下面是一些基本的代码示例：

1.1文件读取

//  1.使用fs核心模块
var fs = require('fs');

/**
 * filename, 必选参数，文件名
 * [options],可选参数，可指定flag（文件操作选项，如r+ 读写；w+ 读写，文件不存在则创建）及encoding属性
 * callback 读取文件后的回调函数，参数默认第一个err,第二个data 数据
 */
fs.readFile('./data/a.txt',function(err,data){
   if(err){
        console.log('文件读取失败');
   }
    else{
         console.log(data.toString());
    }
})


// readFileSynsc();同步操作a也是就是说会等当前执行完后在，才会输出2,（阻塞）
let data = fs.readFileSync('./text.txt');
console.log(data.toString())
console.log(2);

1.2文件写入

//  1.使用fs核心模块
var fs = require('fs');

/**
 * filename, 必选参数，文件名
 * data, 写入的数据，可以字符或一个Buffer对象
 * [options],flag,mode(权限),encoding
 * callback 读取文件后的回调函数，参数默认第一个err,第二个data 数据
 * 文件不存在则会自动创建一个文件
 */
fs.writeFile('./data/a.txt','我是文件写入的信息',function(err){
   if(err){
        console.log('文件写入失败');
   }
})


// 同步版本的写入
fs.writeFileSync('./2.text','我是同步写入的文件')

1.3以追加方式写文件

let fs = require('fs');
/*
* 追加文件内容
* */
fs.appendFile('../data/a.txt', '\n使用fs.appendFile追加文件内容', function (error) {
    if(error){
        console.log('追加文件内容出错');
    }else {
        console.log('追加内容完成');
    }

});

// 同步方式
// fs.appendFileSync('../data/a.txt','追加的内容');

1.4创建文件目录

let fs = require('fs');

/**
 * fs.mkdir(path, [mode], callback);
 * path, 被创建目录的完整路径及目录名；
 * [mode], 目录权限，默认0777
 * [callback(err)], 创建完目录回调函数,err错误对象
 */
fs.mkdir('../data/test1',function (error) {
    if(error){
        console.log('创建文件夹失败');
    }else {
        console.log('创建文件夹成功');
    }
});

/*
* 同步方法
* */
fs.mkdirSync('../data/test2');

1.5读取文件目录

// 异步读取文件夹里面的所有文件
fs.readdir('./',(err,files)=>{
    if (err) {
        console.log(err);
    } else{
        // console.log(files); 返回的文件是个数组,可以用forEach循环输出文件名
        files.forEach((x)=>{
            console.log('有'+ x +'这个文件');
        })
    }
});

// 同步获取文件夹里面的所有文件
let files = fs.readdirSync('./public');
console.log(files); //返回的是一个数组

1.6删除文件

let fs = require('fs');

//异步操作删除1.text
fs.unlink('./1.text',(err)=>{
	if (err) {
		console.log(err);
	} else{
		console.log('删除文件成功');
	}
})

//同步操作删除2.text
fs.unlinkSync('./2.text');

1.7删除文件目录

let fs = require('fs');

// 异步删除文件夹
fs.rmdir('../data/test1',function (error) {
    if(error){
        console.log('删除文件夹失败');
    }else {
        console.log('删除文件夹成功');
    }

});

// 同步方法
fs.rmdirSync('../data/test2');

1.8判断文件信息

let fs = require('fs');

// 异步获取文件的具体信息
fs.stat('../data/a.txt',(err,info)=>{
    if (err) {
        console.log('获取文件信息失败:',err);
    } else{
        // info.isFile() 判断是不是一个文件 返回结果为true
        console.log(info.isFile());
        // false
        console.log(info.isDirectory());
    }
});

// 同步操作获得文件信息并判断是不是文件夹
let file = fs.statSync('./1.text');

if(file.isFile()){
	console.log('这是一个文件');
}else if(file.isDirectory()){
	console.log('只是一个文件夹');
}else{
	console.log('抱歉这不是一个文件或者文件夹');
}

1.9复制大文件

var fs = require('fs');
//创建读取流
var readStream = fs.createReadStream('./1.zip');
//创建写入流
var writeStream = fs.createWriteStream('./2.zip');
//进行大文件的复制
readStream.pipe(writeStream);

2.path模块的使用

path模块用来处理路径相关内容

2.1格式化路径

let path = require('path');
let url = path.normalize('d:\\\hd///arr/indexindex.php');

// d:\hd\arr\index\index.php
console.log(url);

2.2组合多个路径

let path = require('path');
let url = path.join('d:/www','/index','/banner/index.php');
// d:\www\index\banner\index.php
console.log(url);

2.3判断路径是否为绝对路径

const path = require('path');

let url = path.isAbsolute('c:/www/baidu/public/index');//绝对路径(true)
let url_ = path.isAbsolute('www/baidu/public/index');//相对路径(false)

// true ,false
console.log(url,url_);

2.4解析并组合绝对路径

let path = require('path');

//从后往前组合,组合成第一个绝对路径就停止
//若直到要第一个参数都组合不出来绝对路径,那么就会连接上当前脚本所在结对路径,组合成一个完整的绝对路径
let url = path.resolve('c:/www','b:/res','index.php');
let url_ = path.resolve('../data/','a.txt');

// b:\res\index.php
console.log(url);
// F:\vue_project\learn_nodeJs\src\data\a.txt
console.log(url_);

2.5最后一个文件或者文件夹所在的路径

let path = require('path');
//dirname() 返回的是路径最后一个文件或者文件夹的所在路径
let url = path.dirname('F:\\vue_project\\learn_nodeJs\\src\\data\\a.txt');
// F:\vue_project\learn_nodeJs\src\data
console.log(url);

2.6最后的文件或目录名

let path = require('path');
// 返回最后一个文件名或者文件夹名
let url = path.basename('F:\\vue_project\\learn_nodeJs\\src\\data\\a.txt');
console.log(url);

2.7获取文件扩展名

let path = require('path');
// 返回最后一个文件名或者文件夹名
let url = path.extname('../data/a.txt');
console.log(url);

2.8获取当前分隔符

let path = require('path');
let separator = path.sep;
console.log(separator);

let fs = require('fs');
let path = require('path');

let del  = (url)=>{
	//获得所有文件
	let arr = fs.readdirSync(url);
	//循环所有文件
	arr.forEach((x)=>{
		//组合文件路径
		let fileurl = path.resolve(url,x);
		//获得文件的详细信息
		let xinxi =  fs.statSync(fileurl);
		// 判断
		if(xinxi.isFile()){
			fs.unlinkSync(fileurl);//是文件删除
		}else if(xinxi.isDirectory()){
			del(fileurl);//是文件夹递归调用
		}
	})
	//删除文件夹(如果文件夹里面有文件删除不了)
	fs.rmdirSync(url);
}
del(path.resolve(__dirname,'public.1'));

2.10获取指定目录下的文件信息

let fs = require('fs');
let path = require('path');

let del  = (url,y=0)=>{
	
	let h = '';
	for (var i = 0; i < y; i++) {
		h += '---'
	}
	//打印目录二级以后的目录
	console.log(h + url);
	
	//获得所有文件
	let arr = fs.readdirSync(url);
	//循环所有文件
	arr.forEach((x)=>{
		//组合文件路径
		let fileurl = path.resolve(url,x);
		//获得文件的详细信息
		let info =  fs.statSync(fileurl);
		let f ='';
		for (let a=0;a<y+1;a++) {
			f += '---';
		}
		//输出的文件为再次加 ---- 个,(看上班for循环 d+1 )
		!info.isFile(fileurl) || console.log(f + fileurl);
		!info.isDirectory(fileurl) || del(fileurl,y+1);
	})

}
del(path.resolve(__dirname,'public.2'));

结果：
F:\前端学习\node\public.2
---F:\前端学习\node\public.2\06.js
---F:\前端学习\node\public.2\1.vue
---F:\前端学习\node\public.2\16.json
---F:\前端学习\node\public.2\16.vue
---F:\前端学习\node\public.2\ab
------F:\前端学习\node\public.2\ab\06.js
------F:\前端学习\node\public.2\ab\1.vue
------F:\前端学习\node\public.2\ab\16.json
------F:\前端学习\node\public.2\ab\16.vue
------F:\前端学习\node\public.2\ab\index.html
---F:\前端学习\node\public.2\index.html

3.Http模块的使用

3.1基本使用示例代码

示例一：基本的使用

// 1.引入网络相关模块
var http = require('http');

// 2.创建服务器
var server = http.createServer();

// 3.接受请求处理
server.on('request',function (request,response) {
    console.log('收到来自此IP的请求：',request.remoteAddress);
    console.log('请求URL：',request.url);
    response.setHeader('Content-Type','text/plain;charset=utf-8');
    response.write('已响应请求');
    response.end();
});

// 4.绑定并监听此端口号
server.listen(3000,function () {
    console.log('服务已启动');
});

示例二：根据路由返回不同内容


var http = require('http');
var fs = require('fs');

var server = http.createServer();

// 3.接受请求处理
server.on('request',function (request,response) {

    let url = request.url;
    console.log(url);

    // 返回一张图片
    if(url === '/image'){
        fs.readFile('../data/b.jpg',function (error,data) {
            if(error){
                console.log('读取文件失败');
            }else {
                console.log('已读取文件');
                response.setHeader('Content-Type','image/jpeg');
                response.end(data);
            }
        });
    }

});

// 4.绑定并监听此端口号
server.listen(3000,function () {
    console.log('服务已启动');
});

示例三：返回不同的Html模板

//引入http模块相当于php的apache (node.js不像php,http模块是node.js自带的)
let http = require('http');
let fs = require('fs');

//初始化server服务
var server = http.createServer();

//监听端口
server.listen(3000,()=>{
	console.log('---server服务启动,端口3000---');
})

//监听用户请求
//req : 客户端请求的相关信息和方法
//res : 客户端相应的一些方法
server.on('request',(req,res)=>{
	if(req.url == '/'){
		// 读取首页模版
		fs.readFile('./view/index.html',(err,data)=>{
			if(err){
				console.log(err);
			}else{
				res.end(data);
			}
		})
	}else if(req.url == '/list'){
		// 读取列表页模版
		fs.readFile('./view/list.html',(err,data)=>{
			if(err){
				console.log(err);
			}else{
				res.end(data);
			}
		})
	}else if(req.url == '/page'){
		// 读取内容页面模版
		fs.readFile('./view/page.html',(err,data)=>{
			if(err){
				console.log(err);
			}else{
				res.end(data);
			}
		})
	}else{
		res.end('<!DOCTYPE html><html><head><meta charset="UTF-8"></head><body>404页面没找到;</body></html>');
	}
})

3.2模块化的路由封装

var http = require('http');
var url = require('url');
var router = require('./module/router.js');

http.createServer(function(req, res) {
    if(req.url.indexOf('favicon') != -1){
        res.end();
        return false;
    }
    res.writeHead(200,{"Content-Type":"text/html;charset=utf-8"});
    var pathName=url.parse(req.url,true).pathname.replace('/','');
    // 封装的路由函数
    try {
        router[pathName](req,res);
    } catch(e) {
        router['home'](req,res);
    }
    res.end();
}).listen(8001);

//router.js
var ejs = require('ejs');
var url = require('url');

var router={
    home:function(req,res){
        res.end('首页');
    },
    login:function(req,res){
        ejs.renderFile('./views/login.html',{},function(err,data){
            res.end(data);
        })
    },
    dologin:function(req,res){
        var info=url.parse(req.url,true);
        info=JSON.parse(JSON.stringify(info));
        ejs.renderFile('./views/dologin.html',{query:info.query},function(err,data){
            res.end(data);
        })
    }
}

module.exports=router;

4.url模块的使用

引入并打印Url模块，看看都有哪些方法

cosnt url = require('url');
console.log(url);

下面是有关方法的截图

查阅文档发现，以下api其实官方已经弃用了[url=http://nodejs.cn/api/url.html]

但是在这里还是要说一说它的用法

4.1url.parse()方法

cosnt url = require('url');

/*
* url.parse方法：
* urlStr：要解析成对象的url字符串
* parseQueryString：是否解析查询参数，默认为false
* slashesDenoteHost：是否以斜线解析主机名，默认为false
* */
let urlWithStringQuery = url.parse('http://localhost:8080/test?name=xiaoming&age=20');
console.log(urlWithStringQuery);

解析后的内容是个Url对象，可以通过其中的属性访问解析的值

Url {
  protocol: 'http:',
  slashes: true,
  auth: null,
  host: 'localhost:8080',
  port: '8080',
  hostname: 'localhost',
  hash: null,
  search: '?name=xiaoming&age=20',
  // 如果方法的第二个参数为true,这里会解析成object
  // query: [Object: null prototype] { name: 'xiaoming', age: '20' },    
  query: 'name=xiaoming&age=20',
  pathname: '/test',
  path: '/test?name=xiaoming&age=20',
  href: 'http://localhost:8080/test?name=xiaoming&age=20'
}

4.2url.format()方法

format就是parse的返过程，把对象转换成url字符串

const url = require('url');

let urlObj =  {
    protocol: 'http:',
    slashes: true,
    auth: null,
    host: 'localhost:8080',
    port: '8080',
    hostname: 'localhost',
    hash: null,
    search: '?name=xiaoming&age=20',
    query: 'name=xiaoming&age=20',
    pathname: '/test',
    path: '/test?name=xiaoming&age=20',
    href: 'http://localhost:8080/test?name=xiaoming&age=20'
};

let parseUrl = url.format(urlObj);

// 结果：http://localhost:8080/test?name=xiaoming&age=20
console.log(parseUrl);

4.3url.resolve()方法

用于解析Url路径，有以下用法

const url = require('url');
url.resolve('/one/two/three', 'four');         // '/one/two/four'
url.resolve('http://example.com/', '/one');    // 'http://example.com/one'
url.resolve('http://example.com/one', '/two'); // 'http://example.com/two'

4.4url.search方法

这个方法用于获取网址后面的查询参数，或者给网址后面添加查询参数

// 获取查询参数
const myURL = new URL('http://localhost:8080/test?name=xiaoming&age=20');
// 打印结果：
// ?name=xiaoming&age=20
console.log(myURL.search);

// 设置查询参数
const my_url = new URL('http://localhost:8080/test');
my_url.search = 'name=xiaoming&age=20';
// 结果：http://localhost:8080/test?name=xiaoming&age=20
console.log(my_url.href);

4.5 url.searchParams()方法

URLSearchParams接口和 querystring模块有相似的目的，但是 querystring 模块的目的更加通用，因为它可以定制分隔符（＆和=）。但另一方面，这个 API 是专门为 URL 查询字符串而设计的

这个方法来源于URLSearchParams类，但是可以通过url对象获取到，下面是这个方法的使用示例

const myURL = new URL('http://localhost:8080/test?name=xiaoming&age=20');
console.log(myURL.searchParams.get('name'));
console.log(myURL.searchParams.get('age'));

四、模块化与Node中的模块系统

1.什么是模块化

模块化是一种bai将系统分离成du独立功能部zhi分的方法，可将dao系统分割成独立的功能部分zhuan，严格定义shu模块接口、模块间具有透明性。
简单来说只要遵循一定的模块标准约束，就可以形成模块化，常见的js模块化标准有AMD和CommonJS
模块化可以使得文件形成文件作用域，不同文件可以引入其他模块，各个模块解耦合，减少依赖。

2.commonJS规范

2.1有关概念

Node程序由许多个模块组成，每个模块就是一个文件。Node模块采用了CommonJS规范。

根据CommonJS规范，一个单独的文件就是一个模块。每一个模块都是一个单独的作用域，也就是说，在一个文件定义的变量（还包括函数和类），都是私有的，对其他文件是不可见的
CommonJS规范规定，每个模块内部，module变量代表当前模块。这个变量是一个对象，它的exports属性（即module.exports）是对外的接口。加载某个模块，其实是加载该模块的module.exports属性。

Node内部提供一个Module构建函数。所有模块都是Module的实例。每个模块内部，都有一个module对象，代表当前模块。它有以下属性。

属性	说明
id	模块的识别符，通常是带有绝对路径的模块文件名
filename	模块的文件名，带有绝对路径
loaded	返回一个布尔值，表示模块是否已经完成加载
parent	返回一个对象，表示调用该模块的模块
children	返回一个数组，表示该模块要用到的其他模块
exports	表示模块对外输出的值

下面是一个示例文件，最后一行输出module变量。

// example.js
var jquery = require('jquery');
exports.$ = jquery;
console.log(module);

{ id: '.',
  exports: { '$': [Function] },
  parent: null,
  filename: '/path/to/example.js',
  loaded: false,
  children:
   [ { id: '/path/to/node_modules/jquery/dist/jquery.js',
       exports: [Function],
       parent: [Circular],
       filename: '/path/to/node_modules/jquery/dist/jquery.js',
       loaded: true,
       children: [],
       paths: [Object] } ],
  paths:
   [ '/home/user/deleted/node_modules',
     '/home/user/node_modules',
     '/home/node_modules',
     '/node_modules' ]
}

2.2导出成员变量

Node中是模块作用域，默认文件中所有的成员只在当前模块有效，对于希望可以被其他模块访问到的成员，我们需要把这些公开的成员都挂载到exports接口对象中就可以了
node为每一个模块提供了一个exports变量(可以说是一个对象)，指向 module.exports。这相当于每个模块中都有一句这样的命令 var exports = module.exports;

这样，在对外输出时，可以在这个变量上添加方法。例如 exports.add = function ®{return Math.PI * r *r};注意：不能把exports直接指向一个值，这样就相当于切断了 exports 和module.exports 的关系。例如 exports=function(x){console.log(x)};

一个模块的对外接口，就是一个单一的值，不能使用exports输出，必须使用 module.exports输出。module.exports=function(x){console.log(x);};

总结来说：exports可以导出多个值，而modulex.exports只能导出单一的值。根据阮一峰的教程来说，两个不好区分，那就放弃 exports，只用 module.exports 就好。

例子：

使用exports导出多个值

exports.a = 123;
exports.b = function(){
    console.log('bbb')
};
exports.c = {
    foo:"bar"
};
exports.d = 'hello';

使用module.exports导出单一值

module.exports = 'hello';
// 只能导出单一值，后者会覆盖前者
module.exports = function add(x,y) {
    return x+y;
}

不过，也有办法像exports一样导出多个值，那就是导出一个对象

// 也可以通过以下方法来导出多个成员
module.exports = {
    foo = 'hello',
    add:function(){
        return x+y;
    }
};

2.3加载导出的模块

使用require关键字即可

var example = require('./example.js');

模块加载规则：

根据模块的不同，会优先加载不同类型的模块

如果模块已经存在缓存中，则会优先加载缓存中的模块
如果是Node.js中的核心模块，则会先去加载核心模块
如果是第三方库模块(node_modules)，则会去加载第三方库模块
最后才会加载我们手写的模块，一般这个是否都是路径形式的模块了

根据参数的不同格式，require命令去不同路径寻找模块文件。

如果参数字符串以“/”开头，则表示加载的是一个位于绝对路径的模块文件。比如，require(’/home/marco/foo.js’)将加载/home/marco/foo.js
如果参数字符串以“./”开头，则表示加载的是一个位于相对路径（跟当前执行脚本的位置相比）的模块文件。比如，require(’./circle’)将加载当前脚本同一目录的circle.js
如果参数字符串不以“./“或”/“开头，则表示加载的是一个默认提供的核心模块（位于Node的系统安装目录中），或者一个位于各级node_modules目录的已安装模块（全局安装或局部安装）
如果参数字符串不以“./“或”/“开头，而且是一个路径，比如require(‘example-module/path/to/file’)，则将先找到example-module的位置，然后再以它为参数，找到后续路径
如果指定的模块文件没有发现，Node会尝试为文件名添加.js、.json、.node后，再去搜索。.js件会以文本格式的JavaScript脚本文件解析，.json文件会以JSON格式的文本文件解析，.node文件会以编译后的二进制文件解析

模块的缓存：

第一次加载该模块，node会缓存该模块。再次加载，直接从缓存中取出该模块的module.exports属性。

删除模块的缓存缓存保存在require.cache中，可操作该属性进行删除

// 删除指定模块的缓存  
delete require.cache[moduleName];

// 删除所有模块的缓存
Object.keys(require.cache).forEach(function(key){
    delete require.cache[key];
})

五、Node的其他配置

1.NPM

npm全称就是node package manage(node包管理器)，用于下载各种第三方模块资源，例如通过npm命令安装jQuery包（npm install --save jquery），在安装时加上–save会主动生成说明书文件信息（将安装文件的信息添加到package.json里面）

NPM命令行工具：

npm是一个命令行工具，只要安装了node就已经安装了npm。
npm也有版本概念，可以通过npm --version来查看npm的版本

升级NPM(我升我自己)

npm install --global npm

常见的NPM命令：

命令	说明
npm init	生成package.json描述说明文件
npm install	一次性把dependencies选项中的依赖项全部安装
npm install [packageName]	下载依赖包
npm install --save [packageName]	下载并且保存依赖项（package.json文件中的dependencies选项）
npm uninstall [packageName]	只删除，如果有依赖项会依然保存
npm uninstall --save [packageName]	删除的同时也会把依赖信息全部删除
npm help	查看使用帮助
npm cache clear	可以清空NPM本地缓存
npm ls	查看已安装的模块，-g 查看全局已安装的模块
npm config list	查看配置

2.package.json描述文件

每一个项目都要有一个package.json文件（包描述文件，就像产品的说明书一样）

这个文件可以通过npm init自动初始化出来

{
  "name": "cls",
  "version": "1.0.0",
  "description": "这是一个测试项目",
  "main": "main.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "xiaochen",
  "license": "ISC"
}

对于目前来讲，最有用的是dependencies选项，可以用来帮助我们保存第三方包的依赖信息。

如果node_modules删除了也不用担心，只需要在控制面板中npm install就会自动把package.json中的dependencies中所有的依赖项全部都下载回来。

建议每个项目的根目录下都有一个package.json文件
建议执行npm install 包名的时候都加上--save选项，目的是用来保存依赖信息(新版本无需加–save参数也会自动保存了)

除此，还有一个package-lock.json这个文件，出现于Npm5之后。当你安装包的时候，npm都会生成或者更新package-lock.json这个文件

npm5以后的版本安装都不要加--save参数，它会自动保存依赖信息
你安装包的时候，会自动创建或者更新package-lock.json文件
package-lock.json这个文件会包含node_modules中所有包的信息（版本，下载地址…），这样的话重新npm install的时候速度就可以提升
package-lock.json的另外一个作用就是锁定版本号，防止自动升级

3.dirname和filename成员变量

在Node模块中，除了require,exports等模块成员变量之外，还有两个特殊的成员：

__dirname，是一个成员，可以用来动态获取当前文件模块所属目录的绝对路径
__filename，可以用来动态获取当前文件的绝对路径（包含文件名）
__dirname和filename是不受执行node命令所属路径影响的

在文件操作中，使用相对路径是不可靠的，因为node中文件操作的路径被设计为相对于执行node命令所处的路径。所以为了解决这个问题，只需要把相对路径变为绝对路径（绝对路径不受任何影响）就可以了。就可以使用__dirname或者__filename来帮助我们解决这个问题

打印这两个变量的值

console.log('dirname:',__dirname);
console.log('filename:',__filename);

// 输出结果
// dirname: F:\vue_project\learn_nodeJs\src\04-path模块的使用
// filename: F:\vue_project\learn_nodeJs\src\04-path模块的使用\09-filename和dirname成员变量.js

六、Express框架的使用

概念：

Express 是一个方便开发者的 web 框架，可以让开发者可以方便地处理路由，Cookie, 静态文件，上传文件， RESTFULL风格等等常见操作。

1.安装

npm install express --save

2.第一个实例入门

// 1.引入依赖
const express = require('express');

// 2.创建实例
const app = express();

// 3.监听get请求
app.get('/',(req,res)=>{
    res.send('第一个入门实例');
});

app.get('/getData',(req,res)=>{
    let obj = {
        name: '小明',
        age: '20'
    };
    // 这里返回的是格式数据
    // send方法会自动设置返回数据类型，根据传入的数据类型不同
    res.send(obj);
});

// 4.监听端口
app.listen(3000);
console.log('启动完成');

3.中间件(middleware)的使用

中间件(middleware)就是一个方法，这个方法可以用来处理http请求，但是一般情况下，中间件方法需要携带next参数。

它最大的特点就是，一个中间件处理完，再传递给下一个中间件，也就是说可以在下一次请求中访问上一次的数据

3.1使用中间件的例子：

每个中间件可以从App实例，接收三个参数，依次为request对象（代表HTTP请求）、response对象（代表HTTP回应），next回调函数（代表下一个中间件）。每个中间件都可以对HTTP请求（request对象）进行加工，并且决定是否调用next方法，将request对象再传给下一个中间件。

// use方法的使用类似all方法，都是能够接收任何请求，例如：get、post、put/delete…
// path表示请求的路径
// callback为回调函数，接收三个参数requset,response,next
// next回调函数必须被声明执行才能到达下一个中间件
app.use(path,callback);

下面是一个简单的示例：

const express = require('express');

const app = express();

// 默认路径是 "/"
app.use((req,res,next) => {
    console.log('请求经过了中间件');
    next();
});


app.get('/',(req,res,next) => {
    console.log('访问了路径/');
    res.send('访问了路径/');
});

app.get('/test',(req,res,next) => {
    console.log('访问了路径/test');
    res.send('访问了路径/test');
});

最后打印的结果是

服务启动完成...
请求经过了中间件
访问了路径/
请求经过了中间件
访问了路径/test

所以我们可以得出结论，无论是访问任何一个路径，都经过了没有声明访问路径中间件。

下面再看另外一个例子：

const express = require('express');

const app = express();

// 默认路径是 "/"
app.use((req,res,next) => {
    console.log('请求经过了中间件');
    next();
});

app.use('/request',(req,res,next) => {
    console.log('请求经过了request中间件');
    next();
});

app.use('/other',(req,res,next) => {
    console.log('请求经过了other中间件');
    next();
});

app.get('/',(req,res,next) => {
    console.log('访问了路径/');
    res.send('访问了路径/');
});

app.get('/test',(req,res,next) => {
    console.log('访问了路径/test');
    res.send('访问了路径/test');
});

app.get('/request',(req,res,next) => {
    console.log('访问了路径/request');
    res.send('访问了路径/request');
});

当浏览器地址输入http://localhost:3001/时，得到结果

请求经过了中间件
访问了路径/

当浏览器地址输入http://localhost:3001/test时，得到结果

请求经过了中间件
访问了路径/test

当浏览器地址输入http://localhost:3001/request时，得到结果

请求经过了中间件
请求经过了request中间件
访问了路径/request

由此我们又可以得出一个结论，当我们去访问某个路径时，会走没有声明path变量的中间件，也就是默认中间件，还会走声明了对应路径的中间件。

3.2利用中间件传递数据

下面是使用的一个例子

const express = require('express');

const app = express();

app.use('/getData',(req,res,next) => {
    req.student = { name:'xiaoming',age:20 };
    // 必须调用此方法以继续传递到下一个中间件 
    next();
});

app.get('/getData',(req,res) => {
    console.log(req.student);
   res.send(req.student);
});

app.listen(3000,function () {
    console.log('服务已启动');
});

3.3一个简单的应用场景

//引入express框架
const express = require('express');
//创建网站服务器
const app = express();
//网站公告  在函数中没有使用next 所以代码走到这儿就不会往下走了  这就是网站维护时  公告的使用
app.use((req, res, next) => {
    res.send('<h1>当前网站正在维护...</h1>')
});
//查询登录状态
//如果登录了的话  就使用next继续往下执行  否则输出信息  不继续往下执行
app.use('/admin', (req, res, next) => {
    // 业务操作...
    // 设置登录状态
    let isLogin = true;
    //如果用户登录  让请求继续向下执行
    if (isLogin) {
        next();
    } else {
        //如果用户没有登录  直接对客户端做出响应
        res.send('您还没有登录  不能访问/admin这个页面')
    }
})
app.get('/admin', (req, res) => {
    res.send('您已经登录  可以访问当前页面')
})
//自定义404页面
app.use((req, res, next) => {
    //为客户端响应404状态码已经提示信息
    res.status(404).send('当前访问的页面不存在404')

})
app.listen(3000);
console.log("网站服务器启动成功");

3.3错误处理

利用状态码进行错误处理

const express = require('express');
const fs = require('fs');

const app = express();

app.get('/readFile',(req,res,next) => {
    fs.readFile('../data/xx.txt',((err, data) => {
        if(err){
            next(err);
        }else {
            res.send(data.toString(),);
        }
    }));
});

app.use(function (error,req,res,next) {
    console.log(error);
    res.status(500).send(error.message);
});

app.listen(3000,function () {
    console.log('服务已启动');
});

// 给个不存在的路径，结果就会输出：no such file or directory

或者利用try catch处理

const express = require('express');
// 不引入这个模块就会报错
// const fs = require('fs');

const app = express();



app.get('/readFile',(req,res,next) => {
    try {
        fs.readFile('../data/xx.txt', ((err, data) => {
            if (err) {
                next(err);
            } else {
                res.send(data.toString(),);
            }
        }));
    } catch (e) {
        // 传递这个错误对象
        next(e);
    }
});

app.use(function (error,req,res,next) {
    console.log(error);
    res.status(500).send(error.message);
});

app.listen(3000,function () {
    console.log('服务已启动');
});

// 最后输出： fs is not defined

3.4获取get参数

const express = require('express');

const app = express();

app.get('/getStudentById',(req,res) => {
    // 获取到的结果是个对象类型：{ id: '1' }
    console.log(req.query);
    if(req?.query?.id){
        if(req.query.id === '20'){
            res.send({name:'小明',age:18,id:20})
        }else {
            res.send('未找到对应学生');
        }
    }else {
        res.send("<h3>缺乏必要参数！</h3>");
    }
});

app.listen(3000,function () {
    console.log('服务已启动');
});

3.5获取post参数

先安装body-parser模块，用于解析参数

npm install --save body-parser

代码示例，用PostMan发送x-www-form-urlencoded格式数据即可

const express = require('express');
const bodyParser = require('body-parser');

const app = express();

// 利用中间件拦截请求
// extended：true使用第三方模块qs处理，false使用公共模块queryString进行处理
app.use(bodyParser.urlencoded({extended:false}));

app.post('/addStudent',(req,res) => {
    console.log(req.body);
    const s = JSON.stringify(req.body);
    res.send('添加成功:'+s);
});

app.listen(3000,function () {
    console.log('服务已启动');
});

页面显示结果

{"name":"小明","age":18,"id":20}

3.6路径参数

const express = require('express');

const app = express();

app.get('/index/:id/:name',(req,res)=>{
    res.send(req.params);
});

app.listen(3000,function () {
    console.log('服务已启动');
});
// 访问http://localhost:3000/index/1/xiaoming
// 网页显示结果：{"id":"1","name":"xiaoming"}

当然你还可以指定哪些参数不必传,但是至少得传递一个参数，并且传递一个参数时总会给路径最后一个参数赋值

app.get('/index?/:id?/:name',(req,res)=>{
    res.send(req.params);
});

// 例如：访问http://localhost:3000/index/xiaoming
// 结果：{"name":"xiaoming"}

3.7访问静态资源

使用express提供的static方法就好

const express = require('express');
const app = express();

// 访问静态资源
console.log(__dirname);
app.use('/data',express.static('../data/'));

app.listen(3000,function () {
    console.log('服务已启动');
});