1.所有的ES语法在Node中都可以用
JS开发弊端：
1 文件依赖不明确
2 命名冲突
模块化开发
用exports导出模块内部的成员，可以是变量，可以是方法等
eg
exports.sayHi = sayHi;
用module.exports导出：
module.exports.sayHi = sayHi
当exports对象和module.exports对象指向了不同的对象时， 最终以module.exports为准。
用require导入模块
require（' 文件路径 '）,返回值是到处的元素，路径的后缀是可以省略的
系统模块
即：node运行环境提供的API
eg：
fs模块：文件操作模块
const fs = require('fs')
fs.readFile('文件路径'[,''文件编码],callback);
eg:
fs.readFile('../css/index.css','utf-8',(err,doc)=>{
if(err){
}
....
})
PATH模块
主要的功能有：路径拼接（不同的操作系统，文件路径是不同的，如win:'/',''都可以，linux只能'/'）
path.join('路径1','路径2',.....);
用__dirname可以得到当前绝对路径（命令行的工作目录）
eg：
image.png
url模块
用于处理url地址。用法：
const url = require("url")
let params = url.parse(req,url,ture)
params.query就是解析好的参数对象
params.pathname就是不包含请求参数的请求地址
第三方模块
通常又称为 包
- 以JS文件存在
提供实现项目具体开发的API接口。 - 以命令行工具形式存在
辅助项目开发
nodemom
一个第三方的命令行工具
监控文件的保存操作，修改完后自动重新执行
全局安装nodemon，并且用nodemon去执行js文件，而不是用node
mime模块
mime.getType(path)
根据路径，返回资源类型
router模块
用途：实现路由
使用步骤
1 获取路由对象
2 调用路由对象提供的方法创建路由
3 启用路由，是路由生效
image.png
const getRouter = require('router')
const router = getRouter()
router.get('/add',(req,res)=>{
res.end('hello world!')
})
server.on('request',(req,res)=>{
router(req,res,()=>{})
})
serve-static模块
功能：实现静态资源访问
image.png
基本步骤
- 引入系统模块http
- 创建网站服务器
- 为网站服务器对象添加请求事件
- 实现路由功能
4.1 获取客户端的请求方式
4.2 获取客户端的请求地址
获取请求方式：
const method = req.method.toLowerCase()
获取请求地址：
const pathname = url.parse(req.url).pathname
防止页面中文乱码：
res.writeHead(200,{
'content-type':'text/html;charset=utf8'
})
静态资源
静态资源指的是：
服务器端不需要做任何处理，可以直接响应给客户端的资源就是静态资源，例如CSS，JS，Image等
动态资源
相同的请求地址，不同的相应资源，这种资源就是动态资源
eg：
image.png
同步与异步
同步API：只有在当前API执行完成后，才可以去执行下一个API
ｅｇ：
console.log('a')
console.log('b')
必然时先输出a再输出b
异步API：
eg：
setTimeout
区别：
同步API可以从返回值中拿到API执行的结果，但是异步API的不可以的
可以通过匿名函数传参数的方式拿到异步API的执行结果(回调函数)
eg：
function getMsg(callback){
setTimeout(function(){
callback({msg:'111'})
},2000)
}
getMsg(function(data){
console.log(data)
})
在异步API中，如果我们想按一定的顺序执行一些异步API、
方法一：
在回调函数中进行嵌套。eg：
const fs = require('fs')
fs.readFile('./1.txt','utf8',(r1)=>{
console.log(r1);
fs.readFile('./2.txt','utf8',(r2)=>{
console.log(r2);
fs.readFile('./3.txt','utf8',(r3)=>{
console.log(r3)
})
})
})
但是这样写回带来一个问题：过多的嵌套会导致代码不可维护，称为：嵌套地狱。解决方法：
Promise对象
解决嵌套地狱的办法：
const fs = require('fs');
function p1(){
return new Promise((resolve,reject)=>{
fs.readFile('./1.txt','utf8',(err,result)=>{
if(err) reject(err)
else resolve(result)
})
})
// return p1;
}
function p2(){
return new Promise((resolve,reject)=>{
fs.readFile('./2.txt','utf8',(err,result)=>{
if(err) reject(err)
else resolve(result)
})
})
// return p2;
}
function p3(){
return new Promise((resolve,reject)=>{
fs.readFile('./3.txt','utf8',(err,result)=>{
if(err) reject(err)
else resolve(result)
})
})
// return p3
}
p1().then((r1)=>{
console.log(r1)
return p2()
//只需要把p2（）return，下一个then拿到的就是p2对象
}).then((r2)=>{
console.log(r2)
return p3()
}).then((r3)=>{
console.log(r3)
})
但是，promise方法，代码量大，臃肿。
异步函数
const fn = async ()=>{};
async function fn(){}
这样的函数被称为异步函数，这是ES7的语法
写法：
//定义一个异步函数
//异步函数的默认返回值时promise对象
//await关键字 只能出现在异步函数中。
//await 后面跟promise对象 它可以暂停异步函数的执行 等待promise对象返回结构后再向下执行函数
async function fn(){
}
console.log(fn()) //Promise { undefined }
async function fnn(){
throw '发生了一些错误'
return 123;
}
console.log(fnn()) //Promise { 123 }
fnn().then((data)=>{
console.log(data); // 123
}).catch(function(err){
console.log(err); //发生了一些错误。且：写了throw后，原本的return就不再执行了
})
//读取文件的例子
const fs = require('fs')
const promisify = require('util').promisify
//因为fs.readFile返回的不知promise对象，用promisify来改造它
const readFile = promisify(fs.readFile)
async function run(){
let r1 = await readFile('1.txt','utf8')
let r2 = await readFile('2.txt','utf8')
let r3 = await readFile('3.txt','utf8')
console.log(r1);
console.log(r2);
console.log(r3);
}
run()
现在就变得非常地简洁了
Node中的global对象
浏览器中的全局对象是window，node中的全局对象global，在使用中，global可以省略
网友评论