nodejs学习-----封装异步API，学习回调函数

1、 回调函数学习

回调函数定义： 使用者自己定义一个函数，实现这个函数的程序内容，然后把这个函数（入口地址）作为参数传入别人（或系统）的函数中，由别人（或系统）的函数在运行时来调用的函数。函数是你实现的，但由别人（或系统）的函数在运行时通过参数传递的方式调用，这就是所谓的回调函数。

2、 异步回调----读取文件

var fs = require("fs");
fs.readFile('input.txt', function (err, data) {
    if (err) return console.error(err);
    console.log(data.toString());
});
console.log('运行程序');

打印结果

说明读取文件是异步执行的

3、回调函数的应用场景

使用node，express搭建后端api时 由于接下来的一系列业务操作都需要处理文件数据（db.json)，所以我们需要封装异步API（Student.js），

var fs = require('fs')

var dbPath = './db.json'

// find获取学生列表
exports.find = function () {
  fs.readFile(dbPath, function (err, data) {
    //希望获得JSON.parse(data).students
  })
}

等价于想在以下程序中得到fn内部的data

function fn() {
   setTimeout(function(){
     var data = 'hello';
   },1000)
}
调用fn
fn()

如果需要获取一个函数（fn函数）异步操作（定时setTimeout）结果（var data = ‘hello’)，必须通过回调函数来获取.

也就是说回调函数：获取异步操作的结果

function fn(callback) {
   // var callback = function (data) { console,log(data) }
   
   setTimeout(function(){
     var data = 'hello';
     callback (data)
   },1000)
}

fn(function (data) {
    console,log(data)
})

所以最开始我们的问题可以解决，希望获得文件读取操作readFile的读取结果data

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

/**
 * 获取学生列表
 * callback 中的参数
 *        第一个参数是 err
 *            成功是 null
 *            错误是 错误对象
 *        第二个参数是 结果
 *            成功是 数组
 *            错误是 undefined
 * return []
 */
exports.find = function (callback) {
  fs.readFile(dbPath, 'utf8', function (err, data) {
    if (err) {
      return callback(err)
    }
    callback(null, JSON.parse(data).students)
  })
}

在router.js 路由模块

var Student = require('./student')

router.get('/students', function (req, res) {
  Student.find(function (err, students) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.render('index.html', {
      fruits: [
        '苹果',
        '香蕉',
        '橘子'
      ],
      students: students
    })
  })
})

4、扩展

写一个封装异步API，实现添加保存学生的功能，将添加数据保存到json文件中。

路由设计为：

请求方法	请求路径	参数	备注
post	/studens/new	name、age、gender、hobbies	处理添加学生请求

student.js

封装格式要根据调用格式来写
调用的格式应该是
save（{ name ：‘xx', age :18 },function (err) {------ }）
所以封装要添加一个student 学生对象

var fs = require('fs')

var dbPath = './db.json'
/**
 * 添加保存学生
 * @param  {Object}   student  学生对象
 * @param  {Function} callback 回调函数
 */
exports.save = function(student, callback) {
    fs.readFile(dbPath, 'utf8', function(err, data) {
        if (err) {
            return callback(err)
        }
        var students = JSON.parse(data).students

        // 添加 id ，唯一不重复
        student.id = students[students.length - 1].id + 1

        // 把用户传递的对象保存到数组中
        students.push(student)

        // 把对象数据转换为字符串
        var fileData = JSON.stringify({
            students: students
        })

        // 把字符串保存到文件中
        fs.writeFile(dbPath, fileData, function(err) {
            if (err) {
                // 错误就是把错误对象传递给它
                return callback(err)
            }
            // 成功就没错，所以错误对象是 null
            callback(null)
        })
    })
}

在router.js 路由模块中调用

var fs = require('fs')
var Student = require('./student')

// Express 提供了一种更好的方式
// 专门用来包装路由的
var express = require('express')

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

// 2. 把路由都挂载到 router 路由容器中
/*
 * 处理添加学生
 */
router.post('/students/new', function (req, res) {
  // 1. 获取表单数据
  // 2. 处理
  //    将数据保存到 db.json 文件中用以持久化
  // 3. 发送响应
  Student.save(req.body, function (err) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.redirect('/students')
  })
})

总结

引入概念：调用者属于上层，封装者属于下层。
和以往函数不同，以往都是上层调用，下层封装，而回调函数都是相反。

• 上层传递（定义）----router.js

• 下层调用----students.js

router.js中