需求：图书的增删改查，图书数据保存在data.json文件中。

1、Demo结构：

　　

2、首先下载安装node.js，配置环境变量：参考博客

3、项目初始化

　　1）创建项目根目录node-hello，进入到根目录node-hello，右键/在此处打开PowerShell窗口。

　　2）创建app.js文件。

　　3）在控制台输入命令：npm init -y，会自动创建package.json文件。

　　4）在控制台输入命令：npm install mime，会自动创建node_modules文件夹，并下载mime模块到该文件夹，还会自动生成package-lock.json文件。

　　5）npm install underscore，下载underscore模块。underscore的使用参考博客。

4、入口文件app.js

  1. // 加载http模块
  2. var http = require("http");
  3. var fs = require("fs");
  4. var path = require("path");
  5. var mime = require("mime");
  6. var url = require("url");
  7. var querystring = require("querystring");
  8. var _ = require("underscore");
  9.  
  10. // 创建一个http服务对象
  11. http.createServer(function(req, res) {
  12.  
  13.     req.url = req.url.toLowerCase();
  14.     req.method = req.method.toLowerCase();
  15.     if (req.method === 'get') {
  16.         // 通过url模块的parse方法获取用户get请求提交的数据
  17.         // 第二个参数为true时，urlObj的query属性就是所有的请求参数，类型是json对象
  18.         var urlObj = url.parse(req.url, true);
  19.         // console.log(urlObj);
  20.     } 
  21.  
  22.     // 封装fender函数，将render函数挂在到res对象上；第二个参数是模板数据
  23.     res.render = function (filename, templateData) {
  24.         fs.readFile(filename, function(err, data) {
  25.             if(err) {
  26.                 res.writeHead(404, 'not found', {'Content-Type': 'text/html; charset=utf-8'});
  27.                 res.end("404, not found.");
  28.                 return;
  29.             }
  30.  
  31.             if (templateData) {
  32.                 var fn = _.template(data.toString("utf-8"));
  33.                 data = fn(templateData);
  34.             }
  35.  
  36.             res.setHeader('Content-Type', mime.getType(filename));
  37.             res.end(data);
  38.         });
  39.     };
  40.  
  41.     if(req.url === '/' || req.url === '/index') {
  42.         res.render(path.join(__dirname, 'pages/index.html'));
  43.     }
  44.     else if(req.url === '/list') {
  45.         // 第一步：读取data.json文件中的数据，转换为list数组
  46.         fs.readFile(path.join(__dirname, 'data', 'data.json'), 'utf-8', function (err, data) {
  47.             if(err && err.code !== 'ENOENT') {throw err;}
  48.             console.log("data.json原来的内容：" + data); // [{"name":"xxx","price":"xxx"}]]
  49.             var bookList = JSON.parse(data || '[]'); // json数组
  50.  
  51.             // 第二步：在服务器使用模版引擎，将bookList数据和list.html页面结合
  52.             res.render(path.join(__dirname, 'pages/list.html'), {msg:'这是list页面', bookList:bookList});
  53.         });
  54.     }
  55.     else if(req.url.startsWith('/add')) {
  56.         res.render(path.join(__dirname, 'pages/add.html'));
  57.     }
  58.     else if(req.url.startsWith('/submit') && req.method === 'get') { // 如何获取get请求的参数
  59.         // 用户表单提交get请求数据，保存到data/data.json文件中，新数据以追加的形式添加
  60.         console.log(req.url); // /summit?name=xxx&price=xxx
  61.  
  62.         // 首先读取data.json文件的内容
  63.         fs.readFile(path.join(__dirname, 'data', 'data.json'), 'utf-8', function (err, data) {
  64.             if(err && err.code !== 'ENOENT') {throw err;}
  65.             console.log("data.json原来的内容：" + data); // [{"name":"xxx","price":"xxx"}]]
  66.             var list = JSON.parse(data || '[]'); // json数组
  67.  
  68.             // 获取get请求的参数，将用户提交的数据添加到json数组
  69.             var book = urlObj.query;
  70.             // book.id = list.length + 1;
  71.             book.id = list[list.length - 1].id + 1;
  72.             list.push(book);
  73.             console.log("添加一条记录后，data.json的内容："  + JSON.stringify(list));
  74.  
  75.             // 将json数组写入data.json文件
  76.             fs.writeFile(path.join(__dirname, 'data', 'data.json'), JSON.stringify(list), function(err) {
  77.                 if(err) throw err;
  78.                 console.log('写入成功');
  79.             });
  80.         });
  81.  
  82.         // 重定向
  83.         res.statusCode = 302;
  84.         res.statusMessage = 'Found';
  85.         res.setHeader('Location', '/index');
  86.         res.end();
  87.     }
  88.     else if(req.url.startsWith('/submit') && req.method === 'post') { // 如何获取post请求的参数
  89.         var array = []; // 用来保存用户post请求提交的数据
  90.         var postBody;
  91.         req.on('data', function(chunk) {
  92.             // chunk就是浏览器本次data事件提交的一部分数据；chunk是Buffer类型
  93.             console.log("data事件...");
  94.             array.push(chunk);
  95.         });
  96.  
  97.         req.on('end', function() {
  98.             console.log("end事件...");
  99.             // 把array中多个Buffer对象汇总到一个Buffer对象
  100.             postBody = Buffer.concat(array);
  101.             console.log("postBody: " + postBody); // postBody: name=1&price=1
  102.         });
  103.  
  104.         fs.readFile(path.join(__dirname, 'data', 'data.json'), 'utf-8', function (err, data) {
  105.             if(err && err.code !== 'ENOENT') {throw err;}
  106.             console.log("data.json原来的内容：" + data); // [{"name":"xxx","price":"xxx"}]]
  107.             var list = JSON.parse(data || '[]'); // json数组
  108.  
  109.             // 获取get请求的参数，将用户提交的数据添加到json数组
  110.             // querystring对象可以把表单数据 name=xxx&price=xxx => {"name":"xxx","price":"xxx"}
  111.             var book = querystring.parse(postBody.toString("utf-8"));
  112.             // book.id = list.length + 1;
  113.             book.id = list[list.length - 1].id + 1;
  114.             list.push(book);
  115.             console.log("添加一条记录后，data.json的内容："  + JSON.stringify(list));
  116.  
  117.             // 将json数组写入data.json文件
  118.             fs.writeFile(path.join(__dirname, 'data', 'data.json'), JSON.stringify(list), function(err) {
  119.                 if(err) throw err;
  120.                 console.log('写入成功');
  121.             });
  122.         });
  123.  
  124.         /*
  125.         // 首先读取data.json文件的内容
  126.         fs.readFile(path.join(__dirname, 'data', 'data.json'), 'utf-8', function (err, data) {
  127.             if(err && err.code !== 'ENOENT') {throw err;}
  128.             console.log("data.json原来的内容：" + data); // [{"name":"xxx","price":"xxx"}]]
  129.             var list = JSON.parse(data || '[]'); // json数组
  130.  
  131.             // 获取post请求的参数，将用户提交的数据添加到json数组
  132.             // 因为post提交数据的时候，数据量可能比较大，所以可能分多次提交，每次添加一部分数据
  133.             // 此时服务器要获取用户提交的所有数据，必须监听request对象的data事件
  134.             // 什么时候表示浏览器把所有数据都提交到服务器了呢？当request对象的end事件触发
  135.             var array = []; // 用来保存用户post请求提交的数据
  136.             console.log("111...");
  137.             req.on('data', function(chunk) {
  138.                 // chunk就是浏览器本次data事件提交的一部分数据；chunk是Buffer类型
  139.                 console.log("data事件...");
  140.                 array.push(chunk);
  141.             });
  142.             req.on('end', function() {
  143.                 console.log("end事件...");
  144.                 // 把array中多个Buffer对象汇总到一个Buffer对象
  145.                 var postBody = Buffer.concat(array);
  146.                 console.log("postBody: " + postBody);
  147.                 list.push(postBody);
  148.                 console.log("添加一条记录后，data.json的内容："  + JSON.stringify(list));
  149.  
  150.                 // 将json数组写入data.json文件
  151.                 fs.writeFile(path.join(__dirname, 'data', 'data.json'), JSON.stringify(list), function(err) {
  152.                     if(err) throw err;
  153.                     console.log('写入成功');
  154.                 });
  155.             });
  156.  
  157.             console.log("222...");
  158.         });*/
  159.  
  160.         // 重定向
  161.         res.statusCode = 302;
  162.         res.statusMessage = 'Found';
  163.         res.setHeader('Location', '/index');
  164.         res.end();
  165.     }
  166.     else if(req.url.startsWith('/detail') && req.method === 'get') {
  167.         var queryId = urlObj.query.id;
  168.  
  169.         // 第一步：读取data.json文件中的数据，转换为list数组
  170.         fs.readFile(path.join(__dirname, 'data', 'data.json'), 'utf-8', function (err, data) {
  171.             if(err && err.code !== 'ENOENT') {throw err;}
  172.             console.log("data.json原来的内容：" + data); // [{"name":"xxx","price":"xxx"}]]
  173.             var bookList = JSON.parse(data || '[]'); // json数组
  174.  
  175.             // 查询指定id的记录
  176.             var book = {};
  177.             for (var i = 0; i < bookList.length; i++) {
  178.                 if (bookList[i].id == queryId) { // 不能写“===”，因为queryId是字符串类型
  179.                     book = bookList[i];
  180.                 }
  181.             }
  182.  
  183.             // 第二步：在服务器使用模版引擎，将数据和detail.html页面结合
  184.             res.render(path.join(__dirname, 'pages/detail.html'), {book:book});
  185.         });
  186.     }
  187.     else if(req.url.startsWith('/delete') && req.method === 'get') {
  188.         var queryId = urlObj.query.id;
  189.  
  190.         // 第一步：读取data.json文件中的数据，转换为list数组
  191.         fs.readFile(path.join(__dirname, 'data', 'data.json'), 'utf-8', function (err, data) {
  192.             if(err && err.code !== 'ENOENT') {throw err;}
  193.             console.log("data.json原来的内容：" + data); // [{"name":"xxx","price":"xxx"}]]
  194.             var bookList = JSON.parse(data || '[]'); // json数组
  195.  
  196.             // 删除指定id的记录
  197.             for (var i = 0; i < bookList.length; i++) {
  198.                 if (bookList[i].id == queryId) {
  199.                     bookList.splice(i, 1); // 删除起始下标为queryId-1,长度为1的元素
  200.                 }
  201.             }
  202.  
  203.             // 将json数组重新写入data.json文件
  204.             fs.writeFile(path.join(__dirname, 'data', 'data.json'), JSON.stringify(bookList), function(err) {
  205.                 if(err) throw err;
  206.                 console.log('写入成功');
  207.             });    
  208.  
  209.             // 第二步：在服务器使用模版引擎，将bookList数据和list.html页面结合
  210.             res.render(path.join(__dirname, 'pages/list.html'), {msg:'这是list页面', bookList:bookList});
  211.         });
  212.     }
  213.     else if(req.url.includes('static')){
  214.         res.render(path.join(__dirname, req.url));
  215.     }
  216.     else if(req.url.startsWith('/edit') && req.method === 'post') {
  217.         var array = []; // 用来保存用户post请求提交的数据
  218.         var postBody;
  219.         req.on('data', function(chunk) {
  220.             // chunk就是浏览器本次data事件提交的一部分数据；chunk是Buffer类型
  221.             console.log("data事件...");
  222.             array.push(chunk);
  223.         });
  224.  
  225.         req.on('end', function() {
  226.             console.log("end事件...");
  227.             // 把array中多个Buffer对象汇总到一个Buffer对象
  228.             postBody = Buffer.concat(array);
  229.         });
  230.  
  231.         fs.readFile(path.join(__dirname, 'data', 'data.json'), 'utf-8', function (err, data) {
  232.             if(err && err.code !== 'ENOENT') {throw err;}
  233.  
  234.             var bookList = JSON.parse(data || '[]'); // json数组
  235.  
  236.             // 获取get请求的参数，将用户提交的数据添加到json数组
  237.             // querystring对象可以把表单数据 name=xxx&price=xxx => {"name":"xxx","price":"xxx"}
  238.             var book = querystring.parse(postBody.toString("utf-8"));
  239.             console.log("=============book:" + book.id + book.name + book.price);
  240.             for (var i = 0; i < bookList.length; i++) {
  241.                 // console.log("bookList[i].id=" + bookList[i].id);
  242.                 // console.log("book.id=" + book.id);
  243.                 // console.log(bookList[i].id == book.id);
  244.                 if(bookList[i].id == book.id) {
  245.                     bookList[i].name = book.name;
  246.                     bookList[i].price = book.price;
  247.                 }
  248.             }
  249.  
  250.             // 将json数组重新写入data.json文件
  251.             fs.writeFile(path.join(__dirname, 'data', 'data.json'), JSON.stringify(bookList), function(err) {
  252.                 if(err) throw err;
  253.                 console.log('写入成功');
  254.             });    
  255.  
  256.             // 重定向
  257.             res.statusCode = 302;
  258.             res.statusMessage = 'Found';
  259.             res.setHeader('Location', '/list');
  260.             res.end();
  261.             });
  262.     }
  263.     else {
  264.         res.writeHead(404, 'not found', {'Content-Type': 'text/html; charset=utf-8'});
  265.         res.end("404,not found!");
  266.     }
  267. }).listen('8080', function() {
  268.     console.log('服务器已经启动，请访问http://127.0.0.1:8080/');
  269. });

5、common.css

  1. h2 {
  2.     background-color: #ccc;
  3. }

6、html页面

　　add.html

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4.     <title>add页面</title>
  5.     <meta charset="utf-8">
  6.     <link rel="stylesheet" type="text/css" href="/static/css/common.css">
  7. </head>
  8. <body>
  9.     <h2>add页面</h2>
  10.     <form method="get" action="/submit">
  11.     <!-- <form method="post" action="/submit"> -->
  12.         书名: <input type="text" name="name">
  13.         价格: <input type="text" name="price">
  14.         <input type="submit" value="添加">
  15.     </form>
  16. </body>
  17. </html>

　　detail.html

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4.     <title>detail页面</title>
  5.     <meta charset="utf-8">
  6.     <link rel="stylesheet" type="text/css" href="/static/css/common.css">
  7. </head>
  8. <body>
  9.     <h2>detail页面</h2>
  10.     <form method="post" action="/edit">
  11.         <input type="hidden" name="id" value="<%= book.id %>">
  12.         书名：<input type="text" name="name" value="<%= book.name %>"><br/>
  13.         价格：<input type="text" name="price" value="<%= book.price %>"><br/>
  14.         <input type="submit" value="修改">
  15.     </form>
  16. </body>
  17. </html>

　　index.html

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4.     <title>index页面</title>
  5.     <meta charset="utf-8">
  6.     <link rel="stylesheet" type="text/css" href="/static/css/common.css">
  7. </head>
  8. <body>
  9.     <h2>index页面</h2>
  10.     <!-- <img src="/static/images/1.jpg">
  11.     <img src="/static/images/2.png"> -->
  12.     <a href="/list">图书列表</a>
  13. </body>
  14. </html>

　　list.html

  1. <!DOCTYPE html>
  2. <!DOCTYPE html>
  3. <html>
  4. <head>
  5.     <title>list页面</title>
  6.     <meta charset="utf-8">
  7.     <link rel="stylesheet" type="text/css" href="/static/css/common.css">
  8. </head>
  9. <body>
  10.     <h2>list页面</h2>
  11.     <%= msg %>!</h2><br/>
  12.     <!-- <img src="/static/images/1.jpg">
  13.     <img src="/static/images/2.png"> -->
  14.     <a href="/add">添加</a>
  15.  
  16.     <table border="1" cellpadding="0">
  17.         <tr>
  18.             <td>ID</td>
  19.             <td>书名</td>
  20.             <td>价格</td>
  21.             <td>操作</td>
  22.         </tr>
  23.         <% for(var i = 0; i < bookList.length; i++) { %>
  24.         <tr>
  25.             <td><%= bookList[i].id %></td>
  26.             <td><%= bookList[i].name %></td>
  27.             <td><%= bookList[i].price %></td>
  28.             <td>
  29.                 <a href="/detail?id=<%= bookList[i].id %>">查看</a>
  30.                 <a href="/delete?id=<%= bookList[i].id %>">删除</a>
  31.             </td>
  32.         </tr>
  33.         <% } %>
  34.     </table>
  35.  
  36. </body>
  37. </html>

7、node app.js启动项目，浏览器访问主页 ：http://127.0.0.1:8080/

　　

　　

　　

　　测试完后data.json文件的数据：

  1. [{"id":1,"name":"射雕英雄传","price":"45.00"},{"id":2,"name":"天龙八部2","price":"66.00"},
    {"id":3,"name":"倚天屠龙记","price":"50.00"},{"id":4,"name":"Java编程思想2","price":"40.00"},
    {"name":"Java从入门到精通","price":"30.00","id":6},{"name":"ggf","price":"fff","id":8},
    {"name":"af","price":"ff","id":9}]

　

8、封装app.js里面重复代码

  1. // 加载http模块
  2. var http = require("http");
  3. var fs = require("fs");
  4. var path = require("path");
  5. var mime = require("mime");
  6. var url = require("url");
  7. var querystring = require("querystring");
  8. var _ = require("underscore");
  9.  
  10. // 创建一个http服务对象
  11. http.createServer(function(req, res) {
  12.  
  13.     req.url = req.url.toLowerCase();
  14.     req.method = req.method.toLowerCase();
  15.     if (req.method === 'get') {
  16.         // 通过url模块的parse方法获取用户get请求提交的数据
  17.         // 第二个参数为true时，urlObj的query属性就是所有的请求参数，类型是json对象
  18.         var urlObj = url.parse(req.url, true);
  19.         // console.log(urlObj);
  20.     }
  21.  
  22.     // 封装fender函数，将render函数挂在到res对象上；第二个参数是模板数据
  23.     res.render = function (filename, templateData) {
  24.         fs.readFile(filename, function(err, data) {
  25.             if(err) {
  26.                 res.writeHead(404, 'not found', {'Content-Type': 'text/html; charset=utf-8'});
  27.                 res.end("404, not found.");
  28.                 return;
  29.             }
  30.  
  31.             if (templateData) {
  32.                 var fn = _.template(data.toString("utf-8"));
  33.                 data = fn(templateData);
  34.             }
  35.  
  36.             res.setHeader('Content-Type', mime.getType(filename));
  37.             res.end(data);
  38.         });
  39.     };
  40.  
  41.     if(req.url === '/' || req.url === '/index') {
  42.         res.render(path.join(__dirname, 'pages/index.html'));
  43.     }
  44.     else if(req.url === '/list') {
  45.         // 第一步：读取data.json文件中的数据，转换为list数组
  46.         readFile(function(bookList) {
  47.             // 第二步：使用模版引擎，将bookList数据和list.html页面结合
  48.             res.render(path.join(__dirname, 'pages/list.html'), {msg:'这是list页面', bookList:bookList});
  49.         });
  50.     }
  51.     else if(req.url.startsWith('/add')) {
  52.         res.render(path.join(__dirname, 'pages/add.html'));
  53.     }
  54.     else if(req.url.startsWith('/submit') && req.method === 'get') { // 如何获取get请求的参数
  55.         // 用户表单提交get请求数据，保存到data/data.json文件中，新数据以追加的形式添加
  56.         console.log(req.url); // /summit?name=xxx&price=xxx
  57.  
  58.         // 第一步：读取data.json文件中的数据，转换为list数组
  59.         readFile(function(list) {
  60.             // 第二步：获取get请求的参数，将用户提交的数据添加到json数组
  61.             var book = urlObj.query;
  62.             book.id = list[list.length - 1].id + 1;
  63.             list.push(book);
  64.             console.log("添加一条记录后，data.json的内容："  + JSON.stringify(list));
  65.  
  66.             // 第三步：将json数组写入data.json文件，并重定向到list页面
  67.             writeFile(list, res);
  68.         });
  69.     }
  70.     else if(req.url.startsWith('/submit') && req.method === 'post') { // 如何获取post请求的参数
  71.         // 用户表单提交post请求数据，保存到data/data.json文件中，新数据以追加的形式添加
  72.         getPostBodyData(req, function(book) { // post请求数据封装成book(json对象)
  73.             // 读取data.json文件中的数据，转换为list数组
  74.             readFile(function(list) {
  75.                 book.id = list[list.length - 1].id + 1;
  76.                 list.push(book);
  77.                 // console.log("添加一条记录后，data.json的内容："  + JSON.stringify(list));
  78.  
  79.                 // 将json数组写入data.json文件，并重定向到list页面
  80.                 writeFile(list, res);
  81.             });
  82.         });
  83.     }
  84.     else if(req.url.startsWith('/detail') && req.method === 'get') {
  85.         // 第一步：读取data.json文件中的数据，转换为list数组
  86.         readFile(function(bookList) {
  87.             // 第二步：查询指定id的记录
  88.             var book = {};
  89.             for (var i = 0; i < bookList.length; i++) {
  90.                 // 不能写"==="，因为urlObj.query.id是字符串类型
  91.                 if (bookList[i].id == urlObj.query.id) {
  92.                     book = bookList[i];
  93.                     break;
  94.                 }
  95.             }
  96.  
  97.             // 第三步：使用模版引擎，将数据和detail.html页面结合
  98.             res.render(path.join(__dirname, 'pages/detail.html'), {book:book});
  99.         });
  100.     }
  101.     else if(req.url.startsWith('/delete') && req.method === 'get') {
  102.         // 第一步：读取data.json文件中的数据，转换为list数组
  103.         readFile(function(bookList) {
  104.             // 第二步：删除指定id的记录
  105.             for (var i = 0; i < bookList.length; i++) {
  106.                 if (bookList[i].id == urlObj.query.id) {
  107.                     bookList.splice(i, 1); // 删除起始下标为queryId-1,长度为1的元素
  108.                     break;
  109.                 }
  110.             }
  111.  
  112.             // 第三步：将json数组重新写入data.json文件，并重定向到list页面
  113.             writeFile(bookList, res);
  114.         });
  115.     }
  116.     else if(req.url.includes('static')){
  117.         res.render(path.join(__dirname, req.url));
  118.     }
  119.     else if(req.url.startsWith('/edit') && req.method === 'post') {
  120.         getPostBodyData(req, function(book) { // post请求数据封装成book(json对象)
  121.             console.log("=============book:" + book.id + book.name + book.price);
  122.             // 读取data.json文件中的数据，转换为list数组
  123.             readFile(function(bookList) {
  124.                 for (var i = 0; i < bookList.length; i++) {
  125.                     // console.log("bookList[i].id=" + bookList[i].id);
  126.                     // console.log("book.id=" + book.id);
  127.                     console.log(bookList[i].id == book.id);
  128.                     if(bookList[i].id == book.id) {
  129.                         bookList[i].name = book.name;
  130.                         bookList[i].price = book.price;
  131.                         break;
  132.                     }
  133.                 }
  134.  
  135.                 // 将json数组重新写入data.json文件，并重定向到list页面
  136.                 writeFile(bookList, res);
  137.             });
  138.         });
  139.     }
  140.     else {
  141.         res.writeHead(404, 'not found', {'Content-Type': 'text/html; charset=utf-8'});
  142.         res.end("404,not found!");
  143.     }
  144. }).listen('8080', function() {
  145.     console.log('服务器已经启动，请访问http://127.0.0.1:8080/');
  146. });
  147.  
  148. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  149. // 封装读取data.json文件的方法
  150. function readFile(callback) {
  151.     fs.readFile(path.join(__dirname, 'data', 'data.json'), 'utf-8', function (err, data) {
  152.         if(err && err.code !== 'ENOENT') {throw err;}
  153.         console.log("data.json原来的内容：" + data); // [{"name":"xxx","price":"xxx"}]]
  154.         var bookList = JSON.parse(data || '[]'); // json数组
  155.         callback(bookList);
  156.     });
  157. }
  158.  
  159. // 封装写入data.json文件的方法
  160. function writeFile(list, res) { // 参数list的类型：json数组
  161.     fs.writeFile(path.join(__dirname, 'data', 'data.json'), JSON.stringify(list), function(err) {
  162.         if(err) throw err;
  163.         console.log('写入成功');
  164.  
  165.         // 重定向
  166.         res.statusCode = 302;
  167.         res.statusMessage = 'Found';
  168.         res.setHeader('Location', '/list');
  169.         res.end();
  170.  
  171.         // 使用模版引擎，将bookList数据和list.html页面结合
  172.         // res.render(path.join(__dirname, 'pages/list.html'), {msg:'这是list页面', bookList:bookList});
  173.     });
  174. }
  175.  
  176. // 封装写入data.json文件的方法
  177. function writeFile2(data, callback) { // 参数data的类型：字符串
  178.     fs.writeFile(path.join(__dirname, 'data', 'data.json'), data, function(err) {
  179.         if(err) throw err;
  180.         console.log('写入成功');
  181.  
  182.         // 调用callback()来执行当写入数据完毕后的操作
  183.         callback();
  184.     });
  185. }
  186.  
  187. // 封装获取用户post提交的数据的方法
  188. function getPostBodyData(req, callback) {
  189.     var array = []; // 用来保存用户post请求提交的数据
  190.     var postBody;
  191.     req.on('data', function(chunk) {
  192.         // chunk就是浏览器本次data事件提交的一部分数据；chunk是Buffer类型
  193.         console.log("data事件...");
  194.         array.push(chunk);
  195.     });
  196.  
  197.     req.on('end', function() {
  198.         console.log("end事件...");
  199.         // 把array中多个Buffer对象汇总到一个Buffer对象
  200.         var postBody = Buffer.concat(array); // 此处postBody类型：Buffer
  201.         // console.log("postBody: " + postBody); // postBody: name=1&price=1
  202.         // querystring对象可以把表单数据 name=xxx&price=xxx => {"name":"xxx","price":"xxx"}
  203.         postBody = querystring.parse(postBody.toString("utf-8")); // 此处postBody类型：json对象
  204.         callback(postBody);
  205.     });
  206. }

node.js入门学习（四）--Demo图书的增删改查的更多相关文章

  1. Django基础学习四_数据库的增删改查

    今天主要学习两个东西 1.如何对数据库做增删改查 2.如果将数据库中的数据用html的方式返回到前台 一.对数据库中增删改查操作 1.首先需要先见表,见表的方法我们在“http://www.cnblo ...

  2. node.js 实现接口-操作文件进行用户增删改查

    首先安装npm,使用npm安装express npm install express -S /* * @Author: yinxin * @Date: 2020-03-27 10:18:41 * @L ...

  3. Node+Express+node-mysql 实战于演习 全套mysql(增删改查)

    最近这段时间研究Node感觉不错,自己做了一个增删改查,虽然有些简陋,但是思想是想通的,其实所有项目都是增删改查,有助于初学者快速掌握Node 首先 本实例展示的是基于Node+Express+nod ...

  4. 基于renren-fast的快速入门项目实战（实现报表增删改查）

    基于renren-fast的快速入门项目实战(实现报表增删改查) 说明:renren-fast是一个开源的基于springboot的前后端分离手脚架,当前版本是3.0 官方开发文档需付费,对于新手而言 ...

  5. Mysql学习笔记（六）增删改查

    PS:数据库最基本的操作就是增删改查了... 学习内容: 数据库的增删改查 1.增...其实就是向数据库中插入数据.. 插入语句 insert into table_name values(" ...

  6. ssm学习（四）--完整的增删改查demo

    上一篇文章简要介绍了将sping mvc加入整个框架,算是完成了ssm的集成.本节继续前面的内容,结合spring mvc做一个简单的增删改查demo. 1.首先,重写一下GeckoList.jsp页 ...

  7. ES6学习笔记（三）：教你用js面向对象思维来实现 tab栏增删改查功能

    前两篇文章主要介绍了类和对象.类的继承,如果想了解更多理论请查阅<ES6学习笔记(一):轻松搞懂面向对象编程.类和对象>.<ES6学习笔记(二):教你玩转类的继承和类的对象>, ...

  8. MVC3+EF4.1学习系列(二)-------基础的增删改查和持久对象的生命周期变化

    上篇文章中 我们已经创建了EF4.1基于code first的例子  有了数据库 并初始化了一些数据  今天这里写基础的增删改查和持久对象的生命周期变化 学习下原文先把运行好的原图贴来上~~ 一.创建 ...

  9. MongoDB学习总结(二) —— 基本操作命令(增删改查)

    上一篇介绍了MongoDB在Windows平台下的安装,这一篇介绍一下MongoDB的一些基本操作命令. 下面我们直奔主题,用简单的实例依次介绍一下. > 查看所有数据库 (show dbs) ...

随机推荐

  1. MySQL -1- 简介及安装

    第一章 MySQL 大纲介绍 1.官方定义的MySQL DBA工作内容 (1)运维DBA 初级:各版本.各平台安装搭建.升级 中级:体系结构原理.基础管理(启动关闭.初始化配置文件管理.多实例管理.用 ...

  2. 2017.10.21 C组比赛总结

    今天考得不太好,只拿了100+0+0+30=130分... [GDKOI训练]音乐节拍 考场AC了! 其实就是大水一道! 思路:二分查找 每次输入后,输出该时刻所在的区间的编号就好了. 总体难度:★★ ...

  3. 原生js：click和onclick本质的区别（转https://www.cnblogs.com/web1/p/6555662.html）

    原生javascript的click在w3c里边的阐述是DOM button对象,也是html DOM click() 方法,可模拟在按钮上的一次鼠标单击. button 对象代表 HTML 文档中的 ...

  4. PHP 模拟http 请求

    php 模拟请求类 <?php /** * fangdasheng * http 模拟请求 */ class Myhttp { private $apiUrl; // 构造函数 public f ...

  5. selenium2环境搭建----基于python语言

    selenium支持多种语言如java.c#.Python.PHP等,这里基于python语言,所以这里搭建环境时需做俩步操作: ----1.Python环境的搭建 ----2.selenium的安装 ...

  6. mybatis中foreach的用法以及特殊的情况的用法

    foreach的主要用在构建in条件中,它可以在SQL语句中进行迭代一个集合. foreach元素的属性主要有 item,index,collection,open,separator,close. ...

  7. 11.AutoMapper 之值转换器(Value Transformers)

    https://www.jianshu.com/p/b77311546e64 值转换器(Value Transformers) 值转换器应用于单一类型的转换.AutoMapper在分配值之前,会检测该 ...

  8. JS 的 Element元素对象

    在 HTML DOM 中, 元素对象代表着一个 HTML 元素. 元素对象 的 子节点可以是, 可以是元素节点,文本节点,注释节点. NodeList 对象 代表了节点列表,类似于 HTML元素的子节 ...

  9. java String int转换的不同方法

    参考了网上某篇日志的内容,现摘录如下: String转int: 最常见:int i = Integer.parseInt("123"); 罕见:Integer i= Integer ...

  10. hdu 3549 网络流最大流 Ford-Fulkerson

    Ford-Fulkerson方法依赖于三种重要思想,这三个思想就是:残留网络,增广路径和割. Ford-Fulkerson方法是一种迭代的方法.开始时,对所有的u,v∈V有f(u,v)=0,即初始状态 ...