express搭建服务器

01 项目初始化

# 01-项目初始化 
# 生成 package.json 文件
npm init -y

# 02-关联远程仓库
git init

# 03-在项目根目录下创建 .gitignore 文件，此配置文件用于设置哪些文件不用上传到github上

02 安装项目依赖

# 安装项目依赖
npm i express mongoose --save

03 新建文件目录

# 01-创建 public 文件夹 用于存储客户端所用的样式、脚本、静态文件等

# 02-在public文件夹下创建 css、img、js 文件夹

# 03-在项目根目录下创建 app.js 文件

04 生成APP服务

# 01-引入express
# 02-创建APP服务
# 03-开放静态资源
# 04-处理请求
# 05-开放端口

app.js

var express = require('express')
var router = require('./router/router.js')

var bodyParser = require('body-parser')

var app = express()

// 配置art-template
app.engine('html', require('express-art-template'))


// 开放静态资源
app.use('/node_modules/',express.static('./node_modules/'))
app.use('/public/',express.static('./public/'))

// 配置body-parser
app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())

// 配置路由
// router(app)

// 将路由容器挂载到 app 服务中
// app.use(router)
app.use(router)

// 设置端口号
app.listen(3000,() => {
  console.log('Server is running...')
})

router.js

var express = require('express')
// var Student = require('../students')
var Student = require('../mongoose')

// express 提供了一中方法用来包装路由

// 1.创建一个路由容器
var router = express.Router()

// 2.将路由都挂载到Router容器上

/**
 * 渲染学生页面
 */
router.get('/students', (req, res) => {
  // readFile() 读取的文件均是字符串（二进制）
  //  1. readFile() 函数第二个参数可以省略，也可以指定编码格式，例如：'utf-8' 能够解析我们认识的字符
  //  2.也可以通过 data.toString() 的方式进行转换
  // fs.readFile('./db.json', 'utf-8', (err, data) => {
  //   if (err) {
  //     return res.status(500).send('Server error.')
  //   }
  //   // 从文件中读取的数据是字符串，要将字符串转换为对象才能进一步操作数据
  //   var students = JSON.parse(data).students
  //   res.render('index.html', {
  //     fruits: [
  //       '苹果',
  //       '橘子',
  //       '香蕉'
  //     ],
  //     students: students
  //   })
  // })
  Student.find(function (err, students) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.render('index.html', {
      fruits: [
        '苹果',
        '橘子',
        '香蕉'
      ],
      students: students
    })
  })
})

/**
 * 渲染——添加学生页面
 */
router.get('/students/new', (req, res) => {
  res.render('new.html')
})

/**
 * 处理——添加学生
 */
router.post('/students/new', (req, res) => {
  // 1.获取表单数据
  // 2.处理
  // 3.发送响应
  new Student(req.body).save(function (err) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.redirect('/students')
  })
})

/**
 * 渲染——编辑学生页面
 */
router.get('/students/edit', (req, res) => {
  // 1. 根据ID获取要编辑的学生
  // 2. 通过art-template渲染页面
  //    console.log(req.query)
  // 3. 重定向
  Student.findById(req.query.id.replace(/"/g, ''), (err, result) => {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.render('edit.html', { result: result })
  })
})

/**
 * 处理——编辑学生
 */
router.post('/students/edit', (req, res) => {
  // 1.获取表单数据
  // 2.更新
  //  Student.updata()
  // 3.发送响应
  var id = req.body.id.replace(/"/g, "")
  Student.findByIdAndUpdate(id, req.body, function (err) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.redirect('/students')
  })
})

/**
 * 处理——删除学生
 */
router.get('/students/delete', (req, res) => {
  var id = req.query.id.replace(/"/g, "")
  Student.findByIdAndRemove(id, function (err) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.redirect('/students')
  })
})



// 3.导出路由对象
module.exports = router

// 配置路由
// module.exports = function (app) {
//   app.get('/', (req, res) => {
//     // readFile() 读取的文件均是字符串（二进制）
//     //  1. readFile() 函数第二个参数可以省略，也可以指定编码格式，例如：'utf-8' 能够解析我们认识的字符
//     //  2.也可以通过 data.toString() 的方式进行转换
//     fs.readFile('./db.json', 'utf-8', (err, data) => {
//       if (err) {
//         return res.status(500).send('Server error.')
//       }
//       // 从文件中读取的数据是字符串，要将字符串转换为对象才能进一步操作数据
//       var students = JSON.parse(data).students
//       res.render('index.html', {
//         fruits: [
//           '苹果',
//           '橘子',
//           '香蕉'
//         ],
//         students: students
//       })
//     })
//   })
// }

students.js

/**
 * students.js
 * 数据操作文件模块
 * 职责：操作文件中的数据，只处理数据，不关心业务
 */


var fs = require('fs')
var dbPath = './db.json'

/**
 * 根据ID获取指定学生
 */
exports.findById = function (id, callback) {
  fs.readFile(dbPath, 'utf8', (err, data) => {
    if (err) {
      return callback(err)
    }
    var students = JSON.parse(data).students
    var result = students.find(item => {
      return item.id === parseInt(id)
    })
    callback(null, result)
  })
}

/**
 * 获取所有学生
 */
exports.find = function (callback) {
  fs.readFile(dbPath, 'utf-8', (err, data) => {
    if (err) {
      return callback(err)
    }
    callback(null, JSON.parse(data).students)
  })
}

/**
 * 添加保存学生
 */
exports.save = function (student, callback) {
  // 读取数据文件
  fs.readFile(dbPath, 'utf-8', (err, data) => {
    if (err) {
      return callback(err)
    }
    // 将字符串格式转为对象，操作对象
    var students = JSON.parse(data).students

    // 设置ID
    student.id = students.length + 1
    students.push(student)

    // 将对象转为db.json能保存的格式字符串
    var fileData = JSON.stringify({
      students: students
    })

    // 写入文件中
    fs.writeFile(dbPath, fileData, err => {
      if (err) {
        return callback(err)
      }
      callback(null)
    })
  })
}

/**
 * 更新学生
 */
exports.update = function (student, callback) {
  // student.id = student.id *1
  student.id = parseInt(student.id)
  fs.readFile(dbPath, 'utf-8', (err, data) => {
    if (err) {
      return callback(err)
    }
    var students = JSON.parse(data).students

    // 遍历students数组，根据ID找到要修改的对象
    var stu = students.find(function (item) {
      return item.id === student.id
    })

    for (var key in student) {
      stu[key] = student[key]
    }

    // 转换成文件能保存的格式
    var updatelate = JSON.stringify({
      students: students
    })

    // 将修改后的数据写入文件中
    fs.writeFile(dbPath, updatelate, err => {
      if (err) {
        return callback(err)
      }
      callback(null)
    })
  })
}


/**
 * 删除学生
 */
exports.delete = function (id, callback) {
  id = parseInt(id)
  fs.readFile(dbPath, 'utf8', (err, data) => {
    if (err) {
      return callback(err)
    }
    var students = JSON.parse(data).students
    // console.log(students)
    for (const item of students) {
      if (item.id === id) {
        students.splice(id-1,1)
      }
    }
    // console.log(students)
    var remDate = JSON.stringify({
      students: students
    })
    fs.writeFile(dbPath, remDate, err => {
      if (err) {
        return callback(err)
      }
      callback(null)
    })
  })
}

mongoose.js

var mongoose = require('mongoose')

mongoose.connect('mongodb://localhost/test',{useNewUrlParser: true})
mongoose.set('useFindAndModify', false);

var Schema = mongoose.Schema

var studentSchema = new Schema({
  name: {
    type: String,
    required: true
  },
  gender: {
    type: Number,
    enum: [0, 1],
    default: 0
  },
  age: {
    type: Number,
  },
  hobbies: {
    type: String,
  },
})

module.exports = mongoose.model('Student', studentSchema)

Rabbitmq消息队列详解

文章目录

windows下caffe如何单独编译proto文件

　　利用protoc.exe即可编译。　　在protoc.exe当前文件夹下打开cmd，输入命令如下：

flutter (mac) Dart语法

flutter 官网网址：https://flutterchina.club/setup-macos/ 配置环境变量将flutter下载完成之后, 打开终端命令行

PowerPoint也可以速查文稿字数

我们知道，在Word中的“工具”菜单里有个“字数统计”项，很容易了解文稿中的字数，那么在PowerPoint中，我们也会有这样的需求，但是你知不知道PowerPoint中也有统计演示文稿中的字数的功能呢？其实只要我们在PowerPoint中点击“菜单→文件→属性”，打开“属性

pip报错：No module named pip

在用pip安装库时，出现No module named pip 解决步骤：在安装目录下输入python -m ensurepip，我的是在D盘 D:\P

Mahout系列之推荐算法-基于用户协同过滤

Mahout的一大特色就是包含了推荐算法，里面包括了多种常见的算法，下面我们来分析分析。针对基于用户行为数据的推荐算法一般称为协同过滤算法。协同过滤算法有基于领域(neighborhood-based)的方法，隐语义模型(latent factor model)的方法，基于图

Xen

Xen是一个

FCM服务器 admin-SDK接入指引

机器学习——决策树算法

决策树决策树是附加概率结果的一个树状的决策图，是直观的运用统计概率分析的图法。机器学习中决策树是一个预测模型，它表示对象属性和对象值之间的一种映射，树中的每一个节点表示对象属性的判断条件，其分支表示符合节点条件的对象。树的叶子节点表示对象所属的预测

（未解决）fabric-go-sdk创建通道报错invalid options to create identity, invalid org name

搭建一个3orderer节点、4个组织，其中每个组织各2个peer节点的fabric区块链网络，前期已完成网络测试和链码调用测试（使用的官方sacc）均能成功。于是我想试试能不能将