Node代码片段

作者: 宫若石 | 来源:发表于2017-11-22 07:24 被阅读0次

Node与Mysql交互

采用node-mysql开源项目作为Node框架的MySQL扩展库包括以下方面：

1. 连接MySQL数据库操作

2. 查询MySQL数据库操作

3. 修改MySQL数据库操作

4. 插入MySQL数据库操作

5. 删除MySQL数据库操作

6. MySQL数据库连接池

连接MySQL数据库操作

console.info("------  mysql connetion()  ------");
console.info();
var http = require("http");  // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules.mysql");  // 引入mysql模块
console.log("Now start HTTP server on port 6868...");
console.info();
/**
  * 创建数据库连接
  */
var connection = mysql.createConnection({
  host: "localhoset",  // 主机地址
  user: "root",  // 数据库用户名
  password: "root",  // 数据库密码
  database: "nodejs",  // 数据库名称
  port: 3306  // 端口号
});

/**
  * 创建HTTP服务器
  */
http.createServer(function(req, res) {
  res.writeHead(200, {"Content-Type": "text/html;charset=utf8"});
  res.write("<h3>测试 Node.js-MySQL 数据库；连接！</h3><br/>");
  /**
    * 测试数据库连接
    */
  connection.connect(function(err) {
    if(err) {
      res.end("<p>Error Connected to MySQL!</p>");
      return;
    } else {
      res.end('<p>Connected to MySQL!</p>');
    }
  });

}).listen(6868);  // 监听6868端口号

查询MySQL数据库操作

console.log("------ mysql query() ------");
console.info();
var http = require("http");  // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql");  //引入mysql模块
// ......省略12行代码见上代码块对应部分
/**
  * 创建HTTP服务器
  */
  http.createServer(function(req, res) {
    connection.query("select * from userInfo;", function(error, rows, fields) {
      res.writeHead(200, {"Content-Type":text/html;charset=utf8"});
      res.write("<h3>测试 Node.js-MySQL 数据库查询操作</h3><br/>");
      res.end(JSON.stringify(rows));
    });
  }).listen(6868);  // 监听6868端口号

插入MySQL数据库操作

console.log("------ mysql insert() ------");
console.info();
var http = require("http");  // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql");  //引入mysql模块
//......此处省略连接数据库代码，可参考本章节
  connection.query('insert into userinfo(id, name, pwd) values(7, "genius", "12345678");', 
    function(errorinsert, resinsert) {
      if(errorinsert)  console.log(errorinsert);
      console.log("INSERT Return ==> ");
      console.log(resinsert);
    }
  );
//......此处省略连接数据库代码，可参考本章节

删除MySQL数据库操作

console.log("------ mysql delete() ------");
console.info();
var http = require("http");  // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql");  //引入mysql模块
//......此处省略连接数据库代码，可参考本章节
  connection.query('delete from userinfo where id=7;', function(errordelete, resdelete) {
    if(errordelete) console.log(errordelete);
    console.log("DELETE Return ==>");
    console.log(resdelete);
  });
//......此处省略连接数据库代码，可参考本章节

更新MySQL数据库

console.log("------ mysql update() ------");
console.info();
var http = require("http");  // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql");  //引入mysql模块
//......此处省略连接数据库代码，可参考本章节
  connection.query('update userinfo set pwd="87654321" where pwd="12345678";', 
    function(errorupdate, resupdate) {
      if(errorupdate) console.log(errorupdate);
      console.log("Update Return ==>");
      console.log(resupdate);
    }
  );
//......此处省略连接数据库代码，可参考本章节

操作MySQL数据库连接池

console.log("------ mysql pool() ------");
console.info();
var http = require("http");  // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql");  //引入mysql模块
//......省略12行代码，见建立数据连接部分
/**
  * 创建HTTP服务器
  */
  http.createServer(function(req, res) {
  /**
    * 获取数据库连接池
    */
  pool.getConnection(function(err, conn) {
    if(err) {
      console.log("POOL ==> " + err);
      console.log();
    }
    /**
      * 定义SQL查询语句
      * @type {string}
      */
    var selectSQL = 'select * from userinfo';
    /**
      * 执行数据查询操作
      */
      conn.query(selectSQL, function(err, rows) {
        if(err) {
          console.log(err);
          console.log();
        }
        console.log("SELECT ==> ");
        for(var i in rows) {
          console.log(rows[i]);
        }
        conn.release();  // 释放数据库连接
        res.writeHead(200, {"Content-Type": "text/html;charset=utf8"});
        res.write("<h3>测试 Node.js  - MySQL 数据库连接池操作！</h3><br/>");
        res.end(JSON.stringify(rows));
      });
    });
  }).listen(6868);  // 监听6868端口号

Node异步I/O与Async流程控制库

1. Node框架异步I/O机制

2. Node框架异步I/O应用

3. Async流程控制库

Node框架异步I/O机制基础

console.inf("/n");
console.info('------ Node异步编程：基础初步！ ------');
console.inf("/n");
// 使用setTimeout()异步方法初探异步机制
setTimeout(function() {
  console.log('async - print it now');  // 在回调函数内输出信息
}, 3000);
console.log("asyn - print it 3 second later!");  // 异步方法后输出信息
console.inf("/n");
console.inf("------ Node异步编程 ------");
console.inf("/n");

Node框架异常捕获机制

console.info('------ Node异步编程：异常捕获！ ------');
setTimeout(function() {
  try {
    var data = b/0;  //错误的计算
  } catch(e) {
    console.log(e);
  }
}, 1000);
console.info();

Async串行流程控制

console.info('------ Node异步编程：Async series Array');
console.info();
var async = require("async"); // 引用'async'包
/**
  * 使用series函数方法
  */
async.series([
  function(callback) {
    callback(null, 'hello');
  },
  function(callback) {
    callback(null, 'async');
  },
  function(callback) {
    callback(null, 'series');
  }
], function(err, results) {
  console.log(results);
});
console.info();
console.info('------ Node异步编程：Async series ------');

console.info('------ Node异步编程：Async series Json ------');
console.info();
var async = require('async');  // 引用'async'包
/**
  * 使用series函数方法
  */
async.series({
  one: function(callback) {
    callback(null, "hello");
  },
  two: function(callback) {
    callback(null, "async");
  },
 three: function(callback) {
    callback(null, "series");
  },
}, function(err, results) {
    console.log(results);
});
console.info();
console.info('------ Node异步编程： Async series Json ------');

说明：在应用Async流程控制库过程中，async.series()函数完全严格按照串行执行的，它完成的是同步操作的功能。

Async瀑布模式流程控制（串行）

console.info('------ Node异步编程：Async waterfall ------');
console.info();
var async = require('async');  // 引用'async'包
/**
  * 使用waterfall函数方法
  */
async.waterfall([
  function(callback) {
    // 回调函数的第一个参数为非空值时，waterfall会停止执行剩余任务
    callback(null, 1);
  },
  function(data, callbackl) {
    console.info(data);
    callback(‘test’, 2);
  },
  function(data, callback) {
    console.info(data);
    callback(null, 3);
  }
], function(err, results) {
  console.log(results);
});
console.info();
console.info('------ Node异步编程：Async waterfall ------');

Async并行流程控制

console.info('------ Node异步编程：Async parallel ------');
console.info();
var async = require('async');  // 引用'async'包
/**
  * 使用parallel函数方法
  */
  async.parallel([
    function(callback) {
      setTimeout(function() {
        callback(null, 'one');  
      }, 2000);
    },
    function(callback) {
      setTimeout(function() {
        callback(null, 'two');  
      }, 1000);
    }
  ],
  function(err, results) {
    console.log(results);
  });
  console.info();
  console.info('------ Node异步编程：Async parallel ------');

Async限制性并行流程控制

console.info('------ Node异步编程：Async parallelLimit ------');
console.info();
var async = require('async');  // 引用'async'包
/**
  * 使用parallelLimit函数方法
  */
async.parallelLimit([
  function(callback) {
    setTimeout(function() {
      callback(null, 'one');
    }, 1000);
  },
   function(callback) {
     setTimeout(function() {
        callback(null, 'two');
      }, 1000);
  }
],
1,
function(err, results) {
  console.log(results);
));
console.info();
console.info('------ Node异步编程：Async parallelLimit ------');

Async循环流程控制

console.info('------ Node异步编程：Async whilst ------');
console.info();
var async = require('async');
var count = 0;
/**
  * Define JSON Array
  * @type {{name:string, age:number}[]}
  */
var list = [
  {name:'Jack', age:20},
  {name:'Lucy', age:18},
  {name:'Jack', age:20},
  {name:'Lucy', age:18},
  {name:'Lucy', age:18}
];
async.whilst() {
  function() {
    return count < 5;
  },
  function(callback) {
    console.log(count);
    list[count].age += 1;
    count++;
    setTimeout(callback, 1000);
  },
  function(err) {
    console.log(count);
    console.log(list);
  }
};
console.info();
console.info('------ Node异步编程：Async whilst ------');

console.info('------ Node异步编程：Async doWhilst ------');
console.info();
var async = require('async');
var count = 0;
/**
  * Define JSON Array
  * @type {{name:string, age:number}[]}
  */
var list = [
  {name:'Jack', age:20},
  {name:'Lucy', age:18},
  {name:'Jack', age:20},
  {name:'Lucy', age:18},
  {name:'Lucy', age:18}
];
async.doWhilst{
  function(callback) {
    console.log(count);
    list[count].age += 1;
    count++;
    setTimeout(callback, 1000);
  },
  function() {return count < 5},
  function(err) {
    console.log(list);
  }
};
console.info();
console.info('------ Node异步编程：Async doWhilst ------');

Async队列流程控制

console.info('------ Node异步编程：Async queue ------');
console.info();
var async = require('async');
/**
  * 定义一个queue，设worker数量为2
  */、
var q = async.queue(function(task, callback) {
  console.log('worker is processing task:', task.name);
}, 2);
/**
  * 独立加入5个任务
  */
q.push({name: 'foo'}, function(err) {
  console.log('finished processing foo');
});
q.push({name: 'bar'}, function(err) {
  console.log('finished processing bar');
});
q.push({name: 'cap'}, function(err) {
  console.log('finished processing cap');
});
q.push({name: 'egg'}, function(err) {
  console.log('finished processing egg');
});
q.push({name: 'app'}, function(err) {
  console.log('finished processing app');
});
/**
  * listen: 当最后一个任务交给worker时，将调用该函数
  */
q.empty = function() {
  console.log('no more tasks waiting');
}
/**
  * listen: 当所有任务都执行完以后，将调用该函数
  */
q.drain = function() {
  console.log('all tasks have been processed');
}

注意：相对于async.parallel()函数而言，async.queue()函数在很多关键点提供了回调处理，而且pusj新任务的功能也是async.parallel()函数所做不到的，由此可见async.queue()函数的并行处理能力更为强大。

Node Web开发

围绕以下方面：

1. HTTP模块方法与应用

2. HTTPS模块方法与应用

3. Express开发框架应用

构建一个基本的HTTP服务器

console.info("------ http - create basic server ------");
console.info();
var http = require('http');  // 引入http模块
/**
  * 调用http.createServer()方法创建服务器
  */
http.createServer(function(req, res){
  /**
    * 通过res.writeHeader()方法写HTTP文件头
    */
  res.writeHeader(200, {'Content-type' : 'text/html'});
  /**
    * 通过res.write()方法写页面内容
    */
  res.write('<h3>Node.js-HTTP</h3>');
   /**
    * 通过res.end()方法发送响应状态码，并通知服务器消息完成
    */
    res.end('<p>Create Basic HTTP Server</p>');
}).listen(6868);  // 监听6868端口号

说明：当第一次调用response.write()方法时，将会发送缓存的header信息和第一个报文给客户端。当第二次调用response.write()方法时，Node框架假设用户将发送数据流，然后分别地进行发送。意味着响应是缓存到第一次报文的数据块。如果response.write()方法的所有数据被成功刷新到内核缓冲区，则返回true。如果所有或部分数据还处在队列中，则返回false。当缓冲区再次被释放时，drain事件会被分发。

编写一个简单的HTTP客户端

console.info('------ http-create basic client ------');
console.info();
var http = require('http');  // 引入http模块
/**
  * 定义服务器参数字段
  * @type {{hostname: string, port: number, path: string, method: string}}
  */
var options = {
  hostname: 'localhost',  // 定义服务器主机地址
  port: 6868,  // 定义服务器主机端口号
  path: '/',  // 定义服务器路径
  method: 'POST' // 定义服务器访问方式
};
/**
  * 通过http.request()方法
  * 由客户端向HTTP服务器发起请求
  */
var req = http.request(options, function(res) {
  console.log('STATUS: ' + res.statusCode);
  console.log('HEADERS: ' + JSON.stringify(res.headers));
  res.setEncoding('utf8');
  res.on('data', function(chunk) {
    console.log('BODY:' + chunk);
  });
});
/**
  * 监听request对象的'error'事件
  */
req.on('error', function(e) {
  console.log('problme with request: ' + e.message);
});
/**
  * write data to request body
  */
req.write('data/n');
/**
  * write end to request body
  */
req.end();

console.info('------ http - create basic server ------');
console.info();
var http = require('http');  // 引入http模块
// 调用http.createServer()方法创建服务器
http.createServer(function(req, res) {
  // 通过res.writeHeader()方法写HTTP文件头
  res.writedHeader(200, {'Content-Type' : 'text/html'}),
  // 通过res.write()方法写页面内容
  res.write('<h3>Node.js -- HTTP</h3>');
  // 通过res.end()方法响应状态吗，并通知服务器消息完成
  res.end('<p>Create Basic HTTP Server Response to clients request</p>');
}).listen(6868);  // 监听6868端口号
---------------------------------------
####HTTP响应状态码
```javascript
console.info("------ http - create basic client ------");
console.info();
var http = require('http');  // 引入http模块
var querystring = require('querystring');  // 引入Query String模块
/**
  * 定义响应状态码数据
  */
var status_codes = new Array();
status_codes[0] = "201";
status_codes[1] = "202";
status_codes[2] = "203";
status_codes[3] = "401";
status_codes[4] = "402";
/**
  * 定义查询字段
  */
var postData = new Array();
for(var n = 0; n < 5; n++) {
  postData[n] = querystring.stringify({
    statuscodes: status_code[n]
  });
}
/**
  * 模拟HTTP客户端向HTTP服务端连续发送request请求
  */
for(var i = 0; i < 5; i++) {
/**
  * 定义服务器参数字段
  * @type {{hostname: string, port: number, path: string, method: string, headers: {Content-Type: string, Content-Length: *}}}
  */
  var options = {
    hostname: 'localhost',
    port: 6868,
    path: '/' + postData[i],
    method: 'POST',
    header: {
        'Content-Type': 'application/x-www-form-urlencode',
        'Content-Length': postData.length
    }
  };
/**
  * 通过http.request()方法
  *  由客户端向HTTP服务器发起请求
  */
var req = http.requets(options, function(res) {
  console.log('STATUS_CODES:' + res.statusCode);
  console.log('HEADERS: ' + JSON.stringify(res.headers));
  console.info();
  res.setEncoding('utf8');
  res.on('data', function(chunk) {
    console.log('BODY: ' + chunk);
    console.info();
  });
});
/**
  * 监听request对象的'error'事件
  */
req.on(''error', function(e) {
  console.log('problem with request: ' + e.message);
  console.info();
})
/**
  * write data to request body
  */
req.write("/n");
/**
  * write end to request body
  */
req.end();
};

console.info("------ http STATUS_CODES");
console.info();
var http = require('http);  // 引入http模块
console.log("Now start HTTP server...");
console.info();
/**
  * 调用http.createServer()方法创建服务器
  */
http.createServer(function(req, res) {
  var status = req.url,substr(1);  // 获取url查询字段
  var status_codes = status.substring(12);  // 获取HTTP.STATUS_CODES
  // 判断http.STATUS_CODES响应状态码集合是否有效
  if(!http.STATUS_CODES[status_codes]) {
    status_codes = '404';
  }
  // 通过res.writeHeader()方法写HTTP文件头
  res.writeHeader(status_codes, {'Content-Type':'text/plain'});
  // 通过res.end()方法发送响应状码，并通知服务器消息完成
  res.end(http.STATUS_CODES[status_codes]);
}).listen(6868);  // 监听6858端口号

设定和获取HTTP头文件

console.log("------ http - server write header ------");
console.info();
/**
  * 调用http.createServer()方法创建服务器
  */
http.createServer(function(req, res) {
  /**
    * 通过res.writeHead()方法写HTTP文件头
    */
  res.writeHead(200, {
    'Content-Length' : body.length,
    'Content-Type' ： ‘text/plain’
  });
  /**
    * 通过res.write()方法写页面内容
    */
  res.write("Node.js");
  res.write("HTTP");
  /**
    * 通过res.end()方法发送响应状态码， 并通知服务器消息完成
    */
  res.end();
}).listen(6868);  // 监听6868端口号

console.info("------ http - client write header ------");
console.info();
var http = require('http');  // 引入http模块
  /**
    * 定义服务器参数字段
    * @type {{hostname : string, port : number, path : string, method : string}}
    */
var options = {
  hostname: 'localhost',  // 定义服务器主机地址
  port: 6868,  // 定义服务器主机端口号
  path: '/',  // 定义服务器路径
  method: 'POST'  // 定义服务器访问方式
};
/**
  * 通过http.request()方法
  * 由客户端向HTTP服务器发起请求
  */
var req = http.request(options, function(res) {
  console.log('STATUS: ' + res.statusCode);
  console.log('HEADERS: ' + JSON.stringify(res.headers));
  res.setEncoding('utf8');
  res.on('data', funcition(chunk) {
    console.log('BODY: ' + chunk);
  });
});
// 监听request对象的'error'事件
req.on('error', function(e) {
  console.log('problem with request: ' + e.message);
});
req.write('data/n');
re.end();

发送与处理GET请求

console.info("------ http - client get ------');
console.info();
var http = require('http');  // 引入http模块
/**
 * 发送HTTP GET请求
 */
http.get("http://localhost:6868/signature=12345678&echostr=78787878&timestamp=168",
  /**
   * GET回调函数
   * @param res
   */
  function(res) {
    console.log('STATUS: ' + res.statusCode); // 打印输出Status_Codes响应状态码
    console.info();
    /**
     * 监听"data"事件处理函数
     */
    res.on('data', function(chunk) {
      console.log('BODY:' + chunk);
      console.info();
    });
    console.info();
  }).on('error',
    /**
     * "error"事件回调函数
     * @param e
     */
    function(e) {
      console.log("Got error: " + e.message); // 打印出error信息
      console.info();
    }
  );

console.info("------- http - server get ------");
console.info();
var http = require('http'); // 引入http模块
var url = require('url'); // 引入url模块
var qs = require('querystring');  // 引入querystring模块
/**
 * 调用http.createServer()方法创建服务器
 */
http.createServer(function(req, res) {
  /**
   * 通过res.writeHeader()方法写HTTP文件头
   */
  res.writeHeader(200, {'Content-Type' : 'text/plain'});
  /**
   * 通过url.parese()方法获取查询字段
   */
  var query = url.$.parseXML(req.url).query;
  console.info(query);
  console.info();
  /**
   * 通过res.end()方法发送响应状态码，并通知服务器消息完成
   */
  var qs_parse = qs.$.parseXML(query);
  console.info(qs_parse);
  console.info();
  res.end(JSON.stringify(qs_parse));
}).listen(6868);  // 监听6868端口号

进行重定向操作

console.info("------ http - create redirect server A ------");
console.info();
var http = require('http'); // 引入http模块
console.log('Now start HTTP server on port 6868...');
console.info();
/**
 * 调用http.createServer()方法创建服务器
 */
http.createServer(function(req, res) {
  /**
   * 通过res.writeHeader()方法写HTTP文件头
   */
  res.writeHeader(301, {
    'Loaction': 'http://localhost:8686'
  });
  /**
   * 通过res.write()方法写页面内容
   */
  res.write('<h3>Node.js --- HTTP</h3>');
  /**
   * 通过res.end()方法发送响应状态吗，并通知服务器消息完成
   */
  res.end('<p>Create Redirect HTTP Server on Port 6868!</p>');
}).listen(6868);  // 监听6868端口号

console.info("------ http - create redirect server ------");
console.info();
var http = require('http'); // 引入http模块
console.log('Now start HTTP server on 8686...');
console.info();
/**
 * 调用http.createServer()方法创建服务器
 */
http.createServer(function(req, res) {
  // 通过res.writeHeader()方法写HTTP文件头
  res.writeHeader(200, {'Content-type': 'text/html'});
  // 通过res.write()方法写页面内容
  res.write('<h3>Node.js - HTTP</h3>');
  //  通过res.end()方法发送响应状态吗，并通知服务器消息完成
  res.end('<p>Create Redirect HTTP Server on Port 8686!</p>');
}).listen(8686);  // 监听8686端口

服务器多路径处理方式

console.info("------ http - server pathname ------");
console.info();
var http = require('http'); // 引入http模块
var url = require('url'); //  引入url模块
console.log('Now start HTTP server on port 6868...');
console.info();
/**
 * 调用http.createServer()方法创建服务器
 */
http.createServer(function(req, res) {
  /**
   * 获取url.pathname路径
   * @type{path|*|req.pathname|parseTests.pathname|parseTestWithQueryString}
   */
  var pathname = url.parse(req.url).pathname;
  /**
   * Responding to multi type of request
   */
  if(pathname === '/') {
    /**
     * 通过res.writeHeader()方法写HTTP文件头
     */
    res.writeHeader(200, {
      'Content-Type': 'text/plain'
    });
    /**
     * 通过res.end()方法响应状态码，并通知服务器消息完成
     */
    res.end('Home Page/n');
  } else if(pathname === '/about') {
    /**
     * 通过res.writeHeader()方法写HTTP文件头
     */
     res.writeHeader(200, {
       'Content-Type': 'text/plain'
     });
     /**
      * 通过res.write()方法写页面内容
      */
     res.write('Node.js - HTTP/n');
     /**
      * 通过res.end()方法发送响应状态码。并通知服务器消息完成
      */
     res.end('About Us/n');
  } else if(pathname === '/redirect') {
    /**
     * 通过res.writeHeader()方法写HTTP文件头
     */
    res.writeHeader(301, {
      'Location': '/'
    });
    /**
     * 通过res.end()方法发送响应状态码，并通知服务器消息完成
     */
    res.end();
  } else {
    /**
     * 通过res.writeHeader()方法写HTTP文件头
     */
    res.writeHeader(404, {
      'Content-Type': 'text/plain'
    });
    /**
     * 通过res.write()方法写页面内容
     */
    res.write('Node.js - HTTP/n');
    /**
     * 通过res.end()方法发送响应状态码，并通知服务器消息完成
     */
    res.end('Page not found/n');
  }
}).listen(6868);  // 监听6868端口号

模拟ping命令连接服务器

console.info("------ http -client ping ------");
console.info();
var http = require('http'); // 引入http模块
console.log("Now start ping HTTP server...");
console.info();
var http = require('http'); // 引入http模块
console.log("Now start ping HTTP server...");
console.info();
/**
 * 定义查询字段
 */
var options = {
  host: 'localhost',
  port: 6868,
  path: '/'
};

/**
 * 自定义函数 ping_server()
 */
function ping_server() {
  /**
   * 发送HTTP GET请求
   */
  http.get(options. function(res) {
    if(res.statusCode == 200) {
      console.log("The site is up!");
    }
    else {
      console.log('The site is down!');
    }
  }).on('error', function(e) {
    console.log("There was an error: " + e.message);
  });
}
/**进行重定向操作的方法
 * 通过setInterval()方法设定时间间隔
 */
setInterval(ping_server, 1000);

console.info("------ http - server ping ---");
console.info();
var http = require('http'); // 引入http模块
console.log("Now start HTTP server...");
console.info();
/**
 * 调用http.createServer()方法创建服务器
 */
http.createServer(function(req, res) {
  // 通过res.writeHeader()方法写HTTP文件头
  if(Math.round(Math.random())) {
    res.writeHeader(200, {'Content-Type': 'text/html'});
  } else {
    res.writeHeader(404, {'Content-Type': 'text/html'});
  }
  // 通过res.end()方法发送响应状态码，并通知服务器消息完成
  res.end();
}).listen(6868);  // 监听6868端口号

Node代码片段

Node与Mysql交互

1. 连接MySQL数据库操作

2. 查询MySQL数据库操作

3. 修改MySQL数据库操作

4. 插入MySQL数据库操作

5. 删除MySQL数据库操作

6. MySQL数据库连接池

连接MySQL数据库操作

查询MySQL数据库操作

插入MySQL数据库操作

删除MySQL数据库操作

更新MySQL数据库

操作MySQL数据库连接池

Node异步I/O与Async流程控制库

1. Node框架异步I/O机制

2. Node框架异步I/O应用

3. Async流程控制库

Node框架异步I/O机制基础

Node框架异常捕获机制

Async串行流程控制

Async瀑布模式流程控制（串行）

Async并行流程控制

Async限制性并行流程控制

Async循环流程控制

Async队列流程控制

Node Web开发

1. HTTP模块方法与应用

2. HTTPS模块方法与应用

3. Express开发框架应用

构建一个基本的HTTP服务器

编写一个简单的HTTP客户端

设定和获取HTTP头文件

发送与处理GET请求

进行重定向操作

服务器多路径处理方式

模拟ping命令连接服务器

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读