express中间件

app.use()

app.use(path,fun)

app.get(path,fun)
...

app.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()
})

app.get('/user/:id', function (req, res, next) {
  console.log('ID:', req.params.id)
  next()
}, function (req, res, next) {
  res.send('User Info')
})

// handler for the /user/:id path, which prints the user ID
app.get('/user/:id', function (req, res, next) {
  res.end(req.params.id)
})

app.use((req, res, next) => {
  console.log('Logging...');
  next();
});

app.use('/api', (req, res, next) => {
  console.log('API Logging...');
  next();
});

app.use('/api', (req, res, next) => {
  console.log('API Logging...');
  next();
}, (req, res, next) => {
  console.log('API Authentication...');
  next();
});

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

const app = express()

// 定义一个记录ip的中间件
function logIp(req, res, next) {
	console.log(req.ip)
	fs.appendFileSync('ip.txt', req.ip + '\n')
	// 调用next 才能执行下一个中间件
	next()
}

// 记录一个请求时间的中间件
function logTime(req, res, next) {
	console.log(new Date())
	next()
}

// 定义一个请求方法中间件
function logMethod(req, res, next) {
	console.log(req.method)
	next()
}

// 应用中间件 全局性质的
app.use(logIp, logTime)

// 应用中间件 路由局部性质的
app.get('/', logMethod, (req, res) => {
	res.send('hello world')
})

// 这个就只有 logTime logIp 中间件 生效 logMethod不生效
app.get('/user', (req, res) => {
	res.send('user page')
})

// 启动服务
app.listen(3000, () => {
	console.log('server is running at port 3000')
})

var cb0 = function (req, res, next) {
  console.log('CB0');
  next();
}

var cb1 = function (req, res, next) {
  console.log('CB1');
  next();
}

var cb2 = function (req, res) {
  res.send('Hello from C!');
}

app.get('/example/c', [cb0, cb1, cb2]);

app.get('/users/:id', function(req, res, next) {
  var userId = req.params.id;
  if (userId !== '123') {
    next('route'); // 跳过当前路由函数
  } else {
    res.send('User found');
  }
});

app.get('/users/:id', function(req, res, next) {
  res.send('User not found'); // 这个路由函数会被执行
});

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

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

const app = express()

app.use(function (req, res, next) {
	// 假设用户已经登录，将用户信息存储在 req.user 中
	// 对请求和响应对象进行更改
	req.user = {
		id: 123,
		name: 'John Doe',
		email: 'john@example.com',
		hasPaid: false,
	}
	next()
})

// 错误处理中间件 中间件执行顺序问题这里还不能执行到
// app.use(function (err, req, res, next) {
// 	console.error(err)
// 	res.status('404').send('Something broke!')
// })

app.get(
	'/',
	function checkIfPaidSubscriber(req, res, next) {
		if (!req.user.hasPaid) {
			// continue handling this request
			next('错误信息')
		} else {
			next()
		}
	},
	function getPaidContent(req, res, next) {
		res.json({ name: '123' })
	}
	// 也可以自己内部错误中间件，这样优先自己的不会在走全局的出来
	// function getPaidContent(error, req, res, next) {
	// 	console.log(456)
	// 	res.json({ name: '123' })
	// }
)

// 错误处理中间件 错误中间放到最后执行到了
app.use(function (err, req, res, next) {
	console.error(err) // 错误信息
	res.status('500').send('Something broke!')
})

// 启动服务
app.listen(3000, () => {
	console.log('server is running at port 3000')
})

const express = require('express')

// 创建app对象
const app = express()

app.use(express.json())

// 编写中间件
app.post('/login', (req, res, next) => {
  // 1.获取登录传入的用户名和密码
  const { username, password } = req.body

  // 2.对用户名和密码进行判断
  if (!username || !password) {
    next(-1001)
  } else if (username !== 'coderwhy' || password !== '123456') {
    next(-1002)
  } else {
    res.json({
      code: 0,
      message: '登录成功, 欢迎回来~',
      token: '323dfafadfa3222'
    })
  }
})


// 错误处理的中间件
app.use((errCode, req, res, next) => {
  const code = errCode
  let message = '未知的错误信息'

  switch(code) {
    case -1001:
      message = '没有输入用户名和密码'
      break
    case -1002:
      message = '输入用户名或密码错误'
      break
  }

  res.json({ code, message })
})


// 启动服务器
app.listen(9000, () => {
  console.log('express服务器启动成功~')
})

express.static(root, [options])

app.use('/static', express.static(__dirname + '/public'));

// 内置的中间件: 直接将一个文件夹作为静态资源
app.use(express.static('./uploads'))
app.use(express.static('./build'))

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

const app = express()

// 静态资源托管
app.use(express.static('./public'))

// 启动服务
app.listen(3000, () => {
	console.log('server is running at port 3000')
})

//引入express框架
const express = require('express')
//创建服务对象
const app = express()
//静态资源中间件的设置，将当前文件夹下的public目录作为网站的根目录
app.use(express.static('./public')) //当然这个目录中都是一些静态资源
//如果访问的内容经常变化，还是需要设置路由
//但是，在这里有一个问题，如果public目录下有index.html文件，单独也有index.html的路由，
//则谁书写在前，优先执行谁
app.get('/index.html', (request, response) => {
	respsonse.send('首页')
})
//监听端口
app.listen(3000, () => {
	console.log('3000 端口启动....')
})

const express = require('express')

// 创建app对象
const app = express()

// 应用一些中间件
app.use(express.json()) // 解析 
// 解析传递过来urlencoded的时候, 默认使用的node内置querystring模块
// { extended: true }: 不再使用内置的querystring, 而是使用qs第三方库
app.use(express.urlencoded({ extended: true })) // 解析客户端传递过来的urlencoded

// 编写中间件
app.post('/login', (req, res, next) => {
  console.log(req.body)
  res.end('登录成功, 欢迎回来~')
})

// 启动服务器
app.listen(9000, () => {
  console.log('express服务器启动成功~')
})

const express = require('express')

const app = express()

// 创建 json 解析中间
app.use(function (req, res, next) {
	// 获取请求体
	if (req.get('content-type') === 'application/json') {
		// 用于获取  方法提交的数据
		let postData = ''
		req.on('data', (chunk) => {
			postData += chunk
		})

		req.on('end', () => {
			req.body = postData.toString()

			console.log(req.body)

			next()
		})
	} else {
		// 不是json 交给其他中间处理
		next()
	}
})

app.get('/json', (req, res) => {
	const json = req.body
	console.log(json)
	res.end('12')
})

app.listen(3000, () => {
	console.log('启动')
})

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

const app = express()

// 处理json格式的请求体数据  挂在全局使用
// app.use(bodyParser.json())
// 处理post forrmat格式的请求体数据 挂在全局使用
// app.use(bodyParser.urlencoded({ extended: false }))

// 处理post forrmat格式的请求体数据
const urlencodedParser = bodyParser.urlencoded({ extended: false })

// 配置路由
app.get('/', (req, res) => {
	res.sendFile(__dirname + 'public/index.html')
})

// 处理post请求
app.post('/login', urlencodedParser, (req, res) => {
	console.log(req.body) // 使用了body-parser中间件，可以解析请求体数据 例如{ userName: 'qqq', password: '456' }
	res.send('post login')
})

app.post('/login1', (req, res) => {
	console.log(req.body) // undefined 不能解析请求体数据
	res.send('post login')
})

app.post('/login2', bodyParser.json(), (req, res) => {
	console.log(req.body) // 解析json  例如{ userName: 'qqq', password: '456' }
	res.send('post login')
})

// 启动服务
app.listen(3000, () => {
	console.log('server is running at port 3000')
})

const express = require('express')
const multer = require('multer')

// 创建app对象
const app = express()

// 应用一个express编写第三方的中间件
const upload = multer({
  // dest: './uploads'
  storage: multer.diskStorage({
    destination(req, file, callback) {
      callback(null, './uploads')
    },
    filename(req, file, callback) {
      callback(null, Date.now() + '_' + file.originalname)
    }
  })
})

// 编写中间件
// 上传单文件: single方法
app.post('/avatar', upload.single('avatar') , (req, res, next) => {
  console.log(req.file)
  res.end('文件上传成功~')
})

// 上传多文件: 
app.post('/photos', upload.array('photos'), (req, res, next) => {
  console.log(req.files)
  res.end('上传多张照片成功~')
})

// 启动服务器
app.listen(9000, () => {
  console.log('express服务器启动成功~')
})

const express = require('express')
const multer = require('multer')

// 创建app对象
const app = express()

// express内置的插件
app.use(express.json())
app.use(express.urlencoded({ extended: true }))

// 编写中间件
const formdata = multer()

app.post('/login', formdata.any(), (req, res, next) => {
  console.log(req.body)
  res.end('登录成功, 欢迎回来~')
})

// 启动服务器
app.listen(9000, () => {
  console.log('express服务器启动成功~')
})

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

// 创建app对象
const app = express()

// 应用第三方中间件
const writeStream = fs.createWriteStream('./logs/access.log')
app.use(morgan('combined', { stream: writeStream }))

// 编写中间件
app.post('/login', (req, res, next) => {
  res.end('登录成功, 欢迎回来~')
})

// 启动服务器
app.listen(9000, () => {
  console.log('express服务器启动成功~')
})

const express = require('express')

const app = express()

// 1.注册两个普通的中间件
app.use((req, res, next) => {
  console.log('normal middleware01')
  next()
})

app.use((req, res, next) => {
  console.log('normal middleware02')
  next()
})


// 2.注册路径path/method的中间件
app.get('/home', (req, res, next) => {
  console.log('/home get middleware01')
  next()
}, (req, res, next) => {
  console.log('/home get middleware02')
  next()
})

app.post('/login', (req, res, next) => {
  console.log('/login post middleware')
  next()
})


// 3.注册普通的中间件
app.use((req, res, next) => {
  console.log('normal middleware03')
  next()
})

app.use((req, res, next) => {
  console.log('normal middleware04')
})


app.listen(9000, () => {
  console.log('express服务器启动成功~')
})