当前位置：
  1. 首页
  2. node.js
  3. 正文
本文介绍: 学习路径：js基础语法+node.js内置api模块（fs、path、http等）+第三方api模块（express、mysql等)1.在node.js环境中执行js代码在想要执行的代码的目录下打开cmd，然后输入node+要执行的js文件的路径1.按 ↑ 即可快速定位带上一次执行的命令2.使用tab键，能够快速补全路径3.使用esc键，能够快速清空当前已输入的命令4.输入cls+回车可清空终端用来操作文件的模块。读取文件使用 fs.readFile() 方法，也可以使用同步的版本 fs.readFileS

学习路径：js基础语法+node.js内置api模块（fs、path、http等）+第三方api模块（express、mysql等)

1.在node.js环境中执行js代码

在想要执行的代码的目录下打开cmd，然后输入node+要执行的js文件的路径

1.按 ↑ 即可快速定位带上一次执行的命令

2.使用tab键，能够快速补全路径

const fs = require('fs')	//导入fs

fs.readFile('/Users/joe/test.txt', 'utf8' , (err, data) => {
  if (err) {
    console.error(err)
    return
  }
  console.log(data)
})


。。。。。。。。。。。。。。。。。。。。。。。
const fs = require('fs')

try {
  const data = fs.readFileSync('/Users/joe/test.txt', 'utf8')
  console.log(data)
} catch (err) {
  console.error(err)
}

。。。。。。。。。。。。。。。。。。。。。。。。。。

可以通过指定标志来修改默认的行为：
fs.writeFile('/Users/joe/test.txt', content, { flag: 'a+' }, err => {})
const fs = require('fs')		//导入fs

const content = '一些内容'

fs.writeFile('/Users/joe/test.txt', content, err => {
  if (err) {
    console.error(err)
    return
  }
  //文件写入成功。
})

。。。。。。。。。。。。。。。。。。。。。。。。。。。。

const fs = require('fs')

const content = '一些内容'

try {
  const data = fs.writeFileSync('/Users/joe/test.txt', content)
  //文件写入成功。
} catch (err) {
  console.error(err)
}

检查文件夹是否存在

创建新的文件夹

处理路径问题

//1.导入http模块
const http = require('http')
//2.创建web服务器实例
const server = http.createServer()
//3.为服务器实例绑定request事件,调用.on()，监听客户端的请求
server.on(request,(req,res)=>{
	console.log('someone visit our web server')
})
//4.启动服务器
server.listen(8080,function(){
	console.log('server running at http://127.0.0.1:8080')
})
const http = require('http')
const server = http.createServer()
server.on('request',(req, res)=>{
// 1.获取URL地址
const url = req.url
// 2.设置默认的响应内容为404 Not found
let content = "<h1&gt;404 Not found!</h1&gt;"
// 3.判断用户请求的是否为/或/index.html
// 4.判断用户请求的是否为/about.html
if(url === '/' || url ==='/index.html'){
    content = '<h1>首页</h1>'
}else if(url === '/about.html'){
    content = '<h1>关于页面</h1>'
}
// 5.设置Content-Type响应头，防止中文乱码
res.setHeader('Content-Type','text/html; charset=utf-8')
// 6.使用res.end()把内容响应给客户端
res.end(content)
})
server.listen(80,()=>{
    console.log('server running at http://127.0.0.1');
})

加载模块

// 1.加载内置的fs模块
const fs = require('fs')
// 2.加载用户的自定义模块
const custom = require('./模块化.js')
// 3.加载第三方模块
const moment = require('moment')

模块作用域

向外共享模块作用域中的成员

exports和module.exports的使用误区

//1
exports.username = 'zs'
//为module.exports又赋值了一个新的对象
module.exports = {
  gender:'男',
  age:22
}

最终结果是{gender:'男'，age:22}

//2
module.exports.username = 'zs'
//为exports又赋值了一个新的对象
exports = {
  gender:'男',
  age:22
}
最终结果是{usename:'zs'}

//3
//两个都没有赋值新的对象，指向的是同一个对象
exports.username = 'zs'
module.exports.gender='男'
最终结果是{username:'zs',gender:'男'}


//4
exports = {
  username : 'zs',
  gender:'男',
}
module.exports = exports
module.exports.age = '22'
最终结果是{username:'zs',gender:'男'，age:22}

CommonJS规范

为什么需要包？

格式化时间的两种做法

function dateFormat(dtStr){
  const dt = new Date(dtStr)

  const y = dt.getFullYear()
  const m = padZero(dt.getMonth()+1)
  const d = padZero(dt.getDate())

  const hh = padZero(dt.getHours())
  const mm = padZero(dt.getMinutes())
  const ss = padZero(dt.getSeconds())

  return `${y}-${m}-${d} ${hh}:${mm}:${ss}`
}
// 定义补零的函数
function padZero(n){
  return n > 9 ? n : '0' + n
}

module.exports = {
  dateFormat
}
// 导入自定义的格式化时间的模块
const TIME = require('./dateFormat')

// 调用方法，进行时间的格式化
const dt = new Date()
// console.log(dt);
const newDT = TIME.dateFormat(dt)
console.log(newDT);
// 导入需要的包
// 注意：导入的名称就是装包时候的名称
const moment = require('moment')
const dt = moment().format('YYYY-MM-DD HH:mm:ss')
console.log(dt);

包管理配置文件package.json

nrm

i5ting_toc

写包：

{
  "name": "mytools-wq",
  "version": "1.0.0",
  "main": "index.js",
  "description": "提供了格式化时间、HTMLEscape相关的功能",
  "keywords": ["dateFormat","escape"],
  "license": "ISC"

}
// 这是包的入口文件

const date = require('./src/dateFormat')
const escape = require('./src/htmlEscape')


// 向外暴露成员
module.exports = {
  ...date,
  ...escape
}
// 定义格式化时间的函数
function dateFormat(dateStr) {
  const dt = new Date(dateStr)

  const y = dt.getFullYear()
  const m = padZero(dt.getMonth() + 1)
  const d = padZero(dt.getDate())

  const hh = padZero(dt.getHours())
  const mm = padZero(dt.getMinutes())
  const ss = padZero(dt.getSeconds())

  return `${y}-${m}-${d} ${hh}:${mm}:${ss}`
}
// 定义补零的函数
function padZero(n) {
  return n > 9 ? n : '0' + n
}
// 向外暴露成员
module.exports = {
  dateFormat
}
// 定义转义HTML字符的函数
function htmlEscape(htmlStr) {
  return htmlStr.replace(/<|>|"|&amp;/g, (match) => {
    switch (match) {
      case '<':
        return '&amp;lt;'
      case '>':
        return '&amp;gt;'
      case '"':
        return '&amp;quot;'
      case '&amp;':
        return '&amp;amp;'
    }
  })
}

// 定义还原HTML字符串的函数
function htmlUnEscape(htmlStr){
  return htmlStr.replace(/&amp;lt;|&amp;gt;|&amp;quot;|&amp;amp;/g,(match)=>{
    switch(match){
      case '&amp;lt;':
        return "<"
        case '&amp;gt;':
          return '>'
        case '&amp;quot;':
          return '"'
        case '&amp;amp;':
          return '&amp;'

    }
  })
}
// 向外暴露成员
module.exports = {
  htmlEscape,
  htmlUnEscape
}

发布包

删除已发布的包

app.get('请求URL'，function(req,res){ /*处理函数*/}）

app.post('请求URL'，function(req,res){ /*处理函数*/}）

res.send()方法，可以把处理好的内容，发送给客户端（把内容响应给客户端）

// Get 请求
app.get('/', (req, res) => {
	res.send('欢迎使用 Express(GET)');
});

// POST 请求
app.post('/', (req, res) => {
	res.send('欢迎使用 Express(POST)');
});

// Put 请求
app.put('/', (req, res) => {
	res.send('欢迎使用 Express(PUT)');
});

app.delete('/', (req, res) => {
	res.send('欢迎使用 Express(DELETE)');
});


// ... 等等其他请求方式


// 路径支持正则表达式
app.get('/a+b', (req, res) => {
	res.send('类似于 /ab、/aab、/aaab 等的路径均可访问');
})
// 1.导入express
const express = require("express")
// 2.创建web服务器
const app = express()

// 4.监听客户端的GET和POST请求，并向客户端响应具体的内容
app.get('/user',(req,res)=>{
  // 调用express提供的res.send()方法，向客户端响应一个JSON对象
  res.send({name:'zs',age:20,gender:'男'})
})
app.post('/user',(req,res)=>{
  // 调用express提供的res.send()方法，向客户端响应一个文本字符串
  res.send("请求成功")
})
app.get('/',(req,res)=>{
  // 通过req.query可以获取到客户端发送过来的查询参数
  // 注意：默认情况下，req.query是一个空对象
  console.log(req.query);
  res.send(req.query)
})
app.get('/user/:id',(req,res)=>{
  // req.params是动态匹配到的URL参数，默认也是一个空对象。
console.log(req.params);
res.send(req.params)
})
	

// 3.启动web服务器，调用app.listen(端口号，启动成功后的回调函数)
app.listen(80,()=>{
  console.log("express server running at http://127.0.0.1");
})
app.get('/',(req,res)=>{
  // 通过req.query可以获取到客户端发送过来的查询参数
  // 注意：默认情况下，req.query是一个空对象
  console.log(req.query);
  res.send(req.query)
})
//id可以为其他的名称，但是:一定不可省，可以有多个动态参数
app.get('/user/:id',(req,res)=>{
  // req.params是动态匹配到的URL参数，默认也是一个空对象。
console.log(req.params);
res.send(req.params)
})

express中托管静态资源

用法：app.use(express.static('public'))

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

// 在这里，调用express.static()方法，快速的对外提供静态资源
app.use(express.static('想要打开的文件目录'))
app.listen(80,()=>{
  console.log("express server running at http://127.0.0.1");
})

app.use(express.static('public'))

app.use(express.static('files'))

app.use('/public',express.static('public'))

nodemon

npm install -g nodemon

npm install --save-dev nodemon

nodemon [your node app]

nodemon -h 或者 nodemon --help

nodemon ./server.js localhost 8080

nodemon --debug ./server.js 80

路由的匹配过程

路由的使用

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

// 挂载路由
app.get('/',(req,res)=>{
  res.send('hello world')
})
app.post('/',(req,res)=>{
  res.send('Post Request.')
})
app.listen(80,()=>{
  console.log('http://127.0.0.1');
})
// 这是路由模块
// 1.导入express
const express = require('express')
// 2.调用express.Router()函数创建路由对象
const router = express.Router()
// 3.向路由对象上挂载具体的路由
router.get('/',(req,res)=>{
  res.send('Get user list')
})
// 4.使用module.exports向外共享路由对象
module.exports = router

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

// 1.导入路由模块
const router = require('./router.js')
// 2.使用app.use()函数注册路由模块
app.use(router)

//注意app.use()函数的作用，就是来注册全局中间件

app.listen(80,()=>{
  console.log('http://127.0.0.1');
})
var app = express();

// 没有挂载路径的中间件，应用的每个请求都会执行该中间件
app.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

// 挂载至 /user/:id 的中间件，任何指向 /user/:id 的请求都会执行它
app.use('/user/:id', function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

// 路由和句柄函数(中间件系统)，处理指向 /user/:id 的 GET 请求
app.get('/user/:id', function (req, res, next) {
  res.send('USER');
});

next函数的作用

const mw = function(req,res,next){
	
	console.log('这是最简单的中间件函数')
		
	//2把流转关系，转交给下一个中间件或路由
	next()
}

全局生效的中间件

app.use(function(req,res,next){
	console.log('这是一个最简单的中间件函数')
	next()
})

中间件的作用

app.use(function (req, res, next) {
  //  获取到请求到达服务器的时间
  const time = Date.now()
  // 为req对象，挂载自定义属性，从而把时间共享给后面的所有路由
  req.startTime = time
  next()
})

app.get('/', (req, res) => {
  res.send('Home page.' + req.startTime)
})
app.post('/', (req, res) => {
  res.send('User page.' + req.startTime)
})

局部生效的中间件

const mw = (req, res, next) => {
  console.log('调用了局部生效的中间件')
  next()
}

app.get('/', mw, (req, res) => {
  res.send('Home page.')
})
app.get('/user',  (req, res) => {
  res.send('User page.')
})

了解中间件的5个注意事项

中间件的分类

var app = express();

// 没有挂载路径的中间件，应用的每个请求都会执行该中间件
app.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

// 挂载至 /user/:id 的中间件，任何指向 /user/:id 的请求都会执行它
app.use('/user/:id', function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

// 路由和句柄函数(中间件系统)，处理指向 /user/:id 的 GET 请求
app.get('/user/:id', function (req, res, next) {
  res.send('USER');
});
var app = express();
var router = express.Router();

// 没有挂载路径的中间件，通过该路由的每个请求都会执行该中间件
router.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

// 一个中间件栈，显示任何指向 /user/:id 的 HTTP 请求的信息
router.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}, function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

// 一个中间件栈，处理指向 /user/:id 的 GET 请求
router.get('/user/:id', function (req, res, next) {
  // 如果 user id 为 0, 跳到下一个路由
  if (req.params.id == 0) next('route');
  // 负责将控制权交给栈中下一个中间件
  else next(); //
}, function (req, res, next) {
  // 渲染常规页面
  res.render('regular');
});

// 处理 /user/:id， 渲染一个特殊页面
router.get('/user/:id', function (req, res, next) {
  console.log(req.params.id);
  res.render('special');
});

// 将路由挂载至应用
app.use('/', router);
app.get('/', (req, res) => {
  // 人为制造错误
  throw new Error('服务器内部发生了错误！')
})

// 定义错误级别的中间件，捕获整个项目的异常错误，从而防止程序的崩溃
app.use((err,req,res,next)=>{
  console.log('发生了错误'+err.message);
  res.send('Error:' + err.message)
})

app.use()

app.use(express.json)

app.use(express.urlencoded({extended:false}))

 npm install cookie-parser
var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');

// 加载用于解析 cookie 的中间件
app.use(cookieParser());

自定义中间件

//post参数解析中间件
function bodyParser(req,res,next){
    let arr = [];
    req.on("data", chunk => {
        arr.push(chunk);//将读取到的数据存储到数组中
    });
    req.on('end', () => {       //post 数据读取完毕
        let data = Buffer.concat(arr).toString();
        // console.log(qs.parse(data));
        req.body = qs.parse(data);//将读取到的post参数数据存储到request对象中body属性中
        next();//注意，一定要数据读取完毕之后，在顺延(转发)
    })
}
//自定义post参数解析中间件
app.use(bodyParser);
//导入express
const express = require('express')
//创建服务器实例
const app = express()

//配置解析表单数据的中间件
app.use(express.urlencoded({extended:false})) 


// 导入路由模块
const router = require('./apiRouter.js')
// 把路由模块注册到app上
app.use('/api',router)

//启动服务器
app.listen(80, () => {
console.log('http://127.0.0.1')
})
const express = require('express')
const router = express.Router()

// 在这里挂载对应的路由

// get请求
router.get('/get', (req, res) => {
  // 通过req.query获取客户端通过查询字符串，发送到服务器的数据
  const query = req.query
  // 调用res.send()向客户端响应处理的结果
  res.send({
    status: 0, //0表示处理成功，1表示处理失败
    msg: 'GET请求成功！', //状态的描述
    data: query //需要响应给客户端的数据
  })
})

//post请求
router.post('/post', (req, res) => {
  // 1.获取客户端通过的请求体，发送到服务器的URL-encoded数据
  // 如果要获取URL-encoded格式的请求体数据，必须配置中间件app.use(express.urlencoded({extended:false}))
  const body = req.body
  // 2.调用res.send()方法，把数据响应给客户端
  res.send({
    status: 0,
    msg: 'post请求成功',
    data: body
  })
})
module.exports = router

什么是CORS

CORS的注意事项

CORS响应头

app.all('/cors-server',(request,response) => {
    //设置响应头
	//以下都是允许所有的http请求方法
    response.setHeader("Access-Control-Allow-Origin",'*');
    response.setHeader("Access-Control-Allow-Headers",'*');
    response.setHeader("Access-Control-Allow-Method",'*');
    response.send('hello CORS');
})

cors的两种请求

显示所有内容
上一篇 java/php/node.js/python基于智能推荐的博客（博客）系统的设计与开发【2024年毕设】
下一篇 java/php/node.js/python基于协同过滤推荐算法的新闻推荐系统【2024年毕设】

相关文章

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

插入图片
浏览器会保存昵称、邮箱和网站cookies信息，下次评论时使用。