NodeJs学习笔记_01
来源：互联网 发布：unity3d 角色资源 编辑：程序博客网 时间：2024/05/22 06:28
一、创建 Node.js 应用
- 步骤一：引入 required 模块
- 我们使用 require 指令来载入 http 模块，并将实例化的 HTTP 赋值给变量 http，实例如下:
var http = require("http");- 步骤二：创建服务器
- 接下来我们使用 http.createServer() 方法创建服务器，并使用 listen 方法绑定 8888 端口。 函数通过 request, response 参数来接收和响应数据。
- 实例如下，在你项目的根目录下创建一个叫 server.js 的文件，并写入以下代码：
var http = require('http');http.createServer(function (request, response) { // 发送 HTTP 头部 // HTTP 状态值: 200 : OK // 内容类型: text/plain response.writeHead(200, {'Content-Type': 'text/plain'}); // 发送响应数据 "Hello World" response.end('Hello World\n');}).listen(8888);// 终端打印如下信息console.log('Server running at http://127.0.0.1:8888/');Node.js回调函数
var fs = require("fs");fs.readFile('input.txt', function (err, data) { if (err) return console.error(err); console.log(data.toString());});console.log("程序执行结束!");Node.js 事件循环
- Node.js 是单进程单线程应用程序，但是通过事件和回调支持并发，所以性能非常高。
- Node.js 的每一个 API 都是异步的，并作为一个独立线程运行，使用异步函数调用，并处理并发。
- Node.js 基本上所有的事件机制都是用设计模式中观察者模式实现。
- Node.js 单线程类似进入一个while(true)的事件循环，直到没有事件观察者退出，每个异步事件都生成一个事件观察者，如果有事件发生就调用该回调函数.
// 引入 events 模块var events = require('events');// 创建 eventEmitter 对象var eventEmitter = new events.EventEmitter();// 创建事件处理程序var connectHandler = function connected() { console.log('连接成功。'); // 触发 data_received 事件 eventEmitter.emit('data_received');}// 绑定 connection 事件处理程序eventEmitter.on('connection', connectHandler);// 使用匿名函数绑定 data_received 事件eventEmitter.on('data_received', function(){ console.log('数据接收成功。');});// 触发 connection 事件 eventEmitter.emit('connection');console.log("程序执行完毕。");Node.js EventEmitter
- Node.js 所有的异步 I/O 操作在完成时都会发送一个事件到事件队列。
- Node.js里面的许多对象都会分发事件：一个net.Server对象会在每次有新连接时分发一个事件， 一个fs.readStream对象会在文件被打开的时候发出一个事件。 所有这些产生事件的对象都是 events.EventEmitter 的实例。
var events = require('events');var eventEmitter = new events.EventEmitter();// 监听器 #1var listener1 = function listener1() { console.log('监听器 listener1 执行。');}// 监听器 #2var listener2 = function listener2() { console.log('监听器 listener2 执行。');}// 绑定 connection 事件，处理函数为 listener1 eventEmitter.addListener('connection', listener1);// 绑定 connection 事件，处理函数为 listener2eventEmitter.on('connection', listener2);var eventListeners = require('events').EventEmitter.listenerCount(eventEmitter,'connection');console.log(eventListeners + " 个监听器监听连接事件。");// 处理 connection 事件 eventEmitter.emit('connection');// 移除监绑定的 listener1 函数eventEmitter.removeListener('connection', listener1);console.log("listener1 不再受监听。");// 触发连接事件eventEmitter.emit('connection');eventListeners = require('events').EventEmitter.listenerCount(eventEmitter,'connection');console.log(eventListeners + " 个监听器监听连接事件。");console.log("程序执行完毕。");Node.js Buffer(缓冲区)
- 在 Node.js 中，Buffer 类是随 Node 内核一起发布的核心库。Buffer 库为 Node.js 带来了一种存储原始数据的方法，可以让 Node.js 处理二进制数据，每当需要在 Node.js 中处理I/O操作中移动的数据时，就有可能使用 Buffer 库。原始数据存储在 Buffer 类的实例中。一个 Buffer 类似于一个整数数组，但它对应于 V8 堆内存之外的一块原始内存。
Node.js Stream(流)
- Stream 是一个抽象接口，Node 中有很多对象实现了这个接口。例如，对http 服务器发起请求的request 对象就是一个 Stream，还有stdout（标准输出）。
- Node.js，Stream 有四种流类型：
- Readable - 可读操作。
- Writable - 可写操作。
- Duplex - 可读可写操作.
- Transform - 操作被写入数据，然后读出结果。
- 所有的 Stream 对象都是 EventEmitter 的实例。常用的事件有：
- data - 当有数据可读时触发。
- end - 没有更多的数据可读时触发。
- error - 在接收和写入过程中发生错误时触发。
- finish - 所有数据已被写入到底层系统时触发。
- 从流中读取数据
var fs = require("fs");var data = '';// 创建可读流var readerStream = fs.createReadStream('input.txt');// 设置编码为 utf8。readerStream.setEncoding('UTF8');// 处理流事件 --> data, end, and errorreaderStream.on('data', function(chunk) { data += chunk;});readerStream.on('end',function(){ console.log(data);});readerStream.on('error', function(err){ console.log(err.stack);});console.log("程序执行完毕");- 写入流
var fs = require("fs");var data = '菜鸟教程官网地址：www.runoob.com';// 创建一个可以写入的流，写入到文件 output.txt 中var writerStream = fs.createWriteStream('output.txt');// 使用 utf8 编码写入数据writerStream.write(data,'UTF8');// 标记文件末尾writerStream.end();// 处理流事件 --> data, end, and errorwriterStream.on('finish', function() { console.log("写入完成。");});writerStream.on('error', function(err){ console.log(err.stack);});console.log("程序执行完毕");- 管道流
var fs = require("fs");// 创建一个可读流var readerStream = fs.createReadStream('input.txt');// 创建一个可写流var writerStream = fs.createWriteStream('output.txt');// 管道读写操作// 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中readerStream.pipe(writerStream);console.log("程序执行完毕");- 链式流
- 链式是通过连接输出流到另外一个流并创建多个对个流操作链的机制。链式流一般用于管道操作。
- 接下来我们就是用管道和链式来压缩和解压文件。
var fs = require("fs");var zlib = require('zlib');// 压缩 input.txt 文件为 input.txt.gzfs.createReadStream('input.txt') .pipe(zlib.createGzip()) .pipe(fs.createWriteStream('input.txt.gz'));console.log("文件压缩完成。");var fs = require("fs");var zlib = require('zlib');// 解压 input.txt.gz 文件为 input.txtfs.createReadStream('input.txt.gz') .pipe(zlib.createGunzip()) .pipe(fs.createWriteStream('input.txt'));console.log("文件解压完成。");Node.js模块系统
- 为了让Node.js的文件可以相互调用，Node.js提供了一个简单的模块系统。
- 模块是Node.js 应用程序的基本组成部分，文件和模块是一一对应的。换言之，一个 Node.js 文件就是一个模块，这个文件可能是JavaScript 代码、JSON 或者编译过的C/C++ 扩展。
//hello.js function Hello() { var name; this.setName = function(thyName) { name = thyName; }; this.sayHello = function() { console.log('Hello ' + name); }; }; module.exports = Hello;//main.js var Hello = require('./hello'); hello = new Hello(); hello.setName('BYVoid'); hello.sayHello(); - require方法接受以下几种参数的传递：
- http、fs、path等，原生模块。
- ./mod或../mod，相对路径的文件模块。
- /pathtomodule/mod，绝对路径的文件模块。
- mod，非原生模块的文件模块。
- 在路径 Y 下执行 require(X) 语句执行顺序：
1. 如果 X 是内置模块 a. 返回内置模块 b. 停止执行2. 如果 X 以 '/' 开头 a. 设置 Y 为文件根路径3. 如果 X 以 './' 或 '/' or '../' 开头 a. LOAD_AS_FILE(Y + X) b. LOAD_AS_DIRECTORY(Y + X)4. LOAD_NODE_MODULES(X, dirname(Y))5. 抛出异常 "not found"LOAD_AS_FILE(X)1. 如果 X 是一个文件, 将 X 作为 JavaScript 文本载入并停止执行。2. 如果 X.js 是一个文件, 将 X.js 作为 JavaScript 文本载入并停止执行。3. 如果 X.json 是一个文件, 解析 X.json 为 JavaScript 对象并停止执行。4. 如果 X.node 是一个文件, 将 X.node 作为二进制插件载入并停止执行。LOAD_INDEX(X)1. 如果 X/index.js 是一个文件, 将 X/index.js 作为 JavaScript 文本载入并停止执行。2. 如果 X/index.json 是一个文件, 解析 X/index.json 为 JavaScript 对象并停止执行。3. 如果 X/index.node 是一个文件, 将 X/index.node 作为二进制插件载入并停止执行。LOAD_AS_DIRECTORY(X)1. 如果 X/package.json 是一个文件, a. 解析 X/package.json, 并查找 "main" 字段。 b. let M = X + (json main 字段) c. LOAD_AS_FILE(M) d. LOAD_INDEX(M)2. LOAD_INDEX(X)LOAD_NODE_MODULES(X, START)1. let DIRS=NODE_MODULES_PATHS(START)2. for each DIR in DIRS: a. LOAD_AS_FILE(DIR/X) b. LOAD_AS_DIRECTORY(DIR/X)NODE_MODULES_PATHS(START)1. let PARTS = path split(START)2. let I = count of PARTS - 13. let DIRS = []4. while I >= 0, a. if PARTS[I] = "node_modules" CONTINUE b. DIR = path join(PARTS[0 .. I] + "node_modules") c. DIRS = DIRS + DIR d. let I = I - 15. return DIRSNode.js 函数
- 在JavaScript中，一个函数可以作为另一个函数的参数。我们可以先定义一个函数，然后传递，也可以在传递参数的地方直接定义函数。
- Node.js中函数的使用与Javascript类似，举例来说，你可以这样做：
function say(word) { console.log(word);}function execute(someFunction, value) { someFunction(value);}execute(say, "Hello");- 匿名函数
- 我们可以把一个函数作为变量传递。但是我们不一定要绕这个”先定义，再传递”的圈子，我们可以直接在另一个函数的括号中定义和传递这个函数：
function execute(someFunction, value) { someFunction(value);}execute(function(word){ console.log(word) }, "Hello");- 函数传递是如何让HTTP服务器工作的
var http = require("http");http.createServer(function(request, response) { response.writeHead(200, {"Content-Type": "text/plain"}); response.write("Hello World"); response.end();}).listen(8888);Node.js 路由
- server.js代码
var http = require("http");var url = require("url");function start(route) { function onRequest(request, response) { var pathname = url.parse(request.url).pathname; console.log("Request for " + pathname + " received."); route(pathname); response.writeHead(200, {"Content-Type": "text/plain"}); response.write("Hello World"); response.end(); } http.createServer(onRequest).listen(8888); console.log("Server has started.");}exports.start = start;- router.js代码
function route(pathname) { console.log("About to route a request for " + pathname);}exports.route = route;- index.js代码
var server = require("./server");var router = require("./router");server.start(router.route);Node.js 全局对象
- JavaScript 中有一个特殊的对象，称为全局对象（Global Object），它及其所有属性都可以在程序的任何地方访问，即全局变量。
- 在浏览器 JavaScript 中，通常 window 是全局对象， 而 Node.js 中的全局对象是 global，所有全局变量（除了 global 本身以外）都是 global 对象的属性。
// 输出到终端process.stdout.write("Hello World!" + "\n");// 通过参数读取process.argv.forEach(function(val, index, array) { console.log(index + ': ' + val);});// 获取执行路径console.log(process.execPath);// 平台信息console.log(process.platform);Node.js 文件系统
- Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 fs.readFile() 和同步的 fs.readFileSync()。
- 异步的方法函数最后一个参数为回调函数，回调函数的第一个参数包含了错误信息(error)。
- 建议大家是用异步方法，比起同步，异步方法性能更高，速度更快，而且没有阻塞。
var fs = require("fs");// 异步读取fs.readFile('input.txt', function (err, data) { if (err) { return console.error(err); } console.log("异步读取: " + data.toString());});// 同步读取var data = fs.readFileSync('input.txt');console.log("同步读取: " + data.toString());console.log("程序执行完毕。");var fs = require("fs");console.log("准备打开文件！");fs.stat('input.txt', function (err, stats) { if (err) { return console.error(err); } console.log(stats); console.log("读取文件信息成功！"); // 检测文件类型 console.log("是否为文件(isFile) ? " + stats.isFile()); console.log("是否为目录(isDirectory) ? " + stats.isDirectory()); });- 写入
var fs = require("fs");console.log("准备写入文件");fs.writeFile('input.txt', '我是通过写入的文件内容！', function(err) { if (err) { return console.error(err); } console.log("数据写入成功！"); console.log("--------我是分割线-------------") console.log("读取写入的数据！"); fs.readFile('input.txt', function (err, data) { if (err) { return console.error(err); } console.log("异步读取文件数据: " + data.toString()); });});- 读取
var fs = require("fs");var buf = new Buffer(1024);console.log("准备打开已存在的文件！");fs.open('input.txt', 'r+', function(err, fd) { if (err) { return console.error(err); } console.log("文件打开成功！"); console.log("准备读取文件："); fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){ if (err){ console.log(err); } console.log(bytes + " 字节被读取"); // 仅输出读取的字节 if(bytes > 0){ console.log(buf.slice(0, bytes).toString()); } });});- 关流
var fs = require("fs");var buf = new Buffer(1024);console.log("准备打开文件！");fs.open('input.txt', 'r+', function(err, fd) { if (err) { return console.error(err); } console.log("文件打开成功！"); console.log("准备读取文件！"); fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){ if (err){ console.log(err); } // 仅输出读取的字节 if(bytes > 0){ console.log(buf.slice(0, bytes).toString()); } // 关闭文件 fs.close(fd, function(err){ if (err){ console.log(err); } console.log("文件关闭成功"); }); });});- 截取
var fs = require("fs");var buf = new Buffer(1024);console.log("准备打开文件！");fs.open('input.txt', 'r+', function(err, fd) { if (err) { return console.error(err); } console.log("文件打开成功！"); console.log("截取10字节后的文件内容。"); // 截取文件 fs.ftruncate(fd, 10, function(err){ if (err){ console.log(err); } console.log("文件截取成功。"); console.log("读取相同的文件"); fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){ if (err){ console.log(err); } // 仅输出读取的字节 if(bytes > 0){ console.log(buf.slice(0, bytes).toString()); } // 关闭文件 fs.close(fd, function(err){ if (err){ console.log(err); } console.log("文件关闭成功！"); }); }); });});- 删除文件
var fs = require("fs");console.log("准备删除文件！");fs.unlink('input.txt', function(err) { if (err) { return console.error(err); } console.log("文件删除成功！");});- 创建文件
var fs = require("fs");console.log("创建目录 /tmp/test/");fs.mkdir("/tmp/test/",function(err){ if (err) { return console.error(err); } console.log("目录创建成功。");});- 读取目录
var fs = require("fs");console.log("查看 /tmp 目录");fs.readdir("/tmp/",function(err, files){ if (err) { return console.error(err); } files.forEach( function (file){ console.log( file ); });});- 删除目录
var fs = require("fs");// 执行前创建一个空的 /tmp/test 目录console.log("准备删除目录 /tmp/test");fs.rmdir("/tmp/test",function(err){ if (err) { return console.error(err); } console.log("读取 /tmp 目录"); fs.readdir("/tmp/",function(err, files){ if (err) { return console.error(err); } files.forEach( function (file){ console.log( file ); }); });});Node.js GET/POST请求
- 表单提交到服务器一般都使用 GET/POST 请求。
- 获取GET请求内容
- 由于GET请求直接被嵌入在路径中，URL是完整的请求路径，包括了?后面的部分，因此你可以手动解析后面的内容作为GET请求的参数。
var http = require('http');var url = require('url');var util = require('util');http.createServer(function(req, res){ res.writeHead(200, {'Content-Type': 'text/plain; charset=utf-8'}); res.end(util.inspect(url.parse(req.url, true)));}).listen(3000);- 解析
var http = require('http');var url = require('url');var util = require('util');http.createServer(function(req, res){ res.writeHead(200, {'Content-Type': 'text/plain'}); // 解析 url 参数 var params = url.parse(req.url, true).query; res.write("网站名：" + params.name); res.write("\n"); res.write("网站 URL：" + params.url); res.end();}).listen(3000);- 获取 POST 请求内容
POST 请求的内容全部的都在请求体中，http.ServerRequest 并没有一个属性内容为请求体，原因是等待请求体传输可能是一件耗时的工作。
基本语法结构说明
var http = require('http');var querystring = require('querystring');http.createServer(function(req, res){ // 定义了一个post变量，用于暂存请求体的信息 var post = ''; // 通过req的data事件监听函数，每当接受到请求体的数据，就累加到post变量中 req.on('data', function(chunk){ post += chunk; }); // 在end事件触发后，通过querystring.parse将post解析为真正的POST请求格式，然后向客户端返回。 req.on('end', function(){ post = querystring.parse(post); res.end(util.inspect(post)); });}).listen(3000);- 以下实例表单通过 POST 提交并输出数据：
var http = require('http');var querystring = require('querystring');var postHTML = '<html><head><meta charset="utf-8"><title>菜鸟教程 Node.js 实例</title></head>' + '<body>' + '<form method="post">' + '网站名： <input name="name"><br>' + '网站 URL： <input name="url"><br>' + '<input type="submit">' + '</form>' + '</body></html>';http.createServer(function (req, res) { var body = ""; req.on('data', function (chunk) { body += chunk; }); req.on('end', function () { // 解析参数 body = querystring.parse(body); // 设置响应头部信息及编码 res.writeHead(200, {'Content-Type': 'text/html; charset=utf8'}); if(body.name && body.url) { // 输出提交的数据 res.write("网站名：" + body.name); res.write("<br>"); res.write("网站 URL：" + body.url); } else { // 输出表单 res.write(postHTML); } res.end(); });}).listen(3000);Node.js Web 模块
- Web服务器一般指网站服务器，是指驻留于因特网上某种类型计算机的程序，Web服务器的基本功能就是提供Web信息浏览服务。它只需支持HTTP协议、HTML文档格式及URL，与客户端的网络浏览器配合。
- 架构
- Client - 客户端，一般指浏览器，浏览器可以通过 HTTP 协议向服务器请求数据。
- Server - 服务端，一般指 Web 服务器，可以接收客户端请求，并向客户端发送响应数据。
- Business - 业务层， 通过 Web 服务器处理应用程序，如与数据库交互，逻辑运算，调用外部程序等。
- Data - 数据层，一般由数据库组成。
var http = require('http');var fs = require('fs');var url = require('url');// 创建服务器http.createServer( function (request, response) { // 解析请求，包括文件名 var pathname = url.parse(request.url).pathname; // 输出请求的文件名 console.log("Request for " + pathname + " received."); // 从文件系统中读取请求的文件内容 fs.readFile(pathname.substr(1), function (err, data) { if (err) { console.log(err); // HTTP 状态码: 404 : NOT FOUND // Content Type: text/plain response.writeHead(404, {'Content-Type': 'text/html'}); }else{ // HTTP 状态码: 200 : OK // Content Type: text/plain response.writeHead(200, {'Content-Type': 'text/html'}); // 响应文件内容 response.write(data.toString()); } // 发送响应数据 response.end(); }); }).listen(8081);// 控制台会输出以下信息console.log('Server running at http://127.0.0.1:8081/');Node.js Express 框架
- Express 是一个简洁而灵活的 node.js Web应用框架, 提供了一系列强大特性帮助你创建各种 Web 应用，和丰富的 HTTP 工具。
- 使用 Express 可以快速地搭建一个完整功能的网站。
- Express 框架核心特性：
- 可以设置中间件来响应 HTTP 请求。
- 定义了路由表用于执行不同的 HTTP 请求动作。
- 可以通过向模板传递参数来动态渲染 HTML 页面。
//express_demo.js 文件var express = require('express');var app = express();app.get('/', function (req, res) { res.send('Hello World');})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)})- 请求和响应
request 和 response 对象的具体介绍：Request 对象 - request 对象表示 HTTP 请求，包含了请求查询字符串，参数，内容，HTTP 头部等属性。常见属性有：req.app：当callback为外部文件时，用req.app访问express的实例req.baseUrl：获取路由当前安装的URL路径req.body / req.cookies：获得「请求主体」/ Cookiesreq.fresh / req.stale：判断请求是否还「新鲜」req.hostname / req.ip：获取主机名和IP地址req.originalUrl：获取原始请求URLreq.params：获取路由的parametersreq.path：获取请求路径req.protocol：获取协议类型req.query：获取URL的查询参数串req.route：获取当前匹配的路由req.subdomains：获取子域名req.accepts()：检查可接受的请求的文档类型req.acceptsCharsets / req.acceptsEncodings / req.acceptsLanguages：返回指定字符集的第一个可接受字符编码req.get()：获取指定的HTTP请求头req.is()：判断请求头Content-Type的MIME类型Response 对象 - response 对象表示 HTTP 响应，即在接收到请求时向客户端发送的 HTTP 响应数据。常见属性有：res.app：同req.app一样res.append()：追加指定HTTP头res.set()在res.append()后将重置之前设置的头res.cookie(name，value [，option])：设置Cookieopition: domain / expires / httpOnly / maxAge / path / secure / signedres.clearCookie()：清除Cookieres.download()：传送指定路径的文件res.get()：返回指定的HTTP头res.json()：传送JSON响应res.jsonp()：传送JSONP响应res.location()：只设置响应的Location HTTP头，不设置状态码或者close responseres.redirect()：设置响应的Location HTTP头，并且设置状态码302res.send()：传送HTTP响应res.sendFile(path [，options] [，fn])：传送指定路径的文件 -会自动根据文件extension设定Content-Typeres.set()：设置HTTP头，传入object可以一次设置多个头res.status()：设置HTTP状态码res.type()：设置Content-Type的MIME类型- 路由
var express = require('express');var app = express();// 主页输出 "Hello World"app.get('/', function (req, res) { console.log("主页 GET 请求"); res.send('Hello GET');})// POST 请求app.post('/', function (req, res) { console.log("主页 POST 请求"); res.send('Hello POST');})// /del_user 页面响应app.get('/del_user', function (req, res) { console.log("/del_user 响应 DELETE 请求"); res.send('删除页面');})// /list_user 页面 GET 请求app.get('/list_user', function (req, res) { console.log("/list_user GET 请求"); res.send('用户列表页面');})// 对页面 abcd, abxcd, ab123cd, 等响应 GET 请求app.get('/ab*cd', function(req, res) { console.log("/ab*cd GET 请求"); res.send('正则匹配');})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)})- 静态文件
- Express 提供了内置的中间件 express.static 来设置静态文件如：图片， CSS, JavaScript 等。
- 你可以使用 express.static 中间件来设置静态文件路径。例如，如果你将图片， CSS, JavaScript 文件放在 public 目录下，你可以这么写：
app.use(express.static('public'));
var express = require('express');var app = express();app.use(express.static('public'));app.get('/', function (req, res) { res.send('Hello World');})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)- GET 请求
var express = require('express');var app = express();app.use(express.static('public'));app.get('/index.htm', function (req, res) { res.sendFile( __dirname + "/" + "index.htm" );})app.get('/process_get', function (req, res) { // 输出 JSON 格式 var response = { "first_name":req.query.first_name, "last_name":req.query.last_name }; console.log(response); res.end(JSON.stringify(response));})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)})- POST请求
var express = require('express');var app = express();var bodyParser = require('body-parser');// 创建 application/x-www-form-urlencoded 编码解析var urlencodedParser = bodyParser.urlencoded({ extended: false })app.use(express.static('public'));app.get('/index.htm', function (req, res) { res.sendFile( __dirname + "/" + "index.htm" );})app.post('/process_post', urlencodedParser, function (req, res) { // 输出 JSON 格式 var response = { "first_name":req.body.first_name, "last_name":req.body.last_name }; console.log(response); res.end(JSON.stringify(response));})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)})- 上传文件
- index.html
<html><head><title>文件上传表单</title></head><body><h3>文件上传：</h3>选择一个文件上传: <br /><form action="/file_upload" method="post" enctype="multipart/form-data"><input type="file" name="image" size="50" /><br /><input type="submit" value="上传文件" /></form></body></html>- servier.js
var express = require('express');var app = express();var fs = require("fs");var bodyParser = require('body-parser');var multer = require('multer');app.use(express.static('public'));app.use(bodyParser.urlencoded({ extended: false }));app.use(multer({ dest: '/tmp/'}).array('image'));app.get('/index.htm', function (req, res) { res.sendFile( __dirname + "/" + "index.htm" );})app.post('/file_upload', function (req, res) { console.log(req.files[0]); // 上传的文件信息 var des_file = __dirname + "/" + req.files[0].originalname; fs.readFile( req.files[0].path, function (err, data) { fs.writeFile(des_file, data, function (err) { if( err ){ console.log( err ); }else{ response = { message:'File uploaded successfully', filename:req.files[0].originalname }; } console.log( response ); res.end( JSON.stringify( response ) ); }); });})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)})- cookie 管理
// express_cookie.js 文件var express = require('express')var cookieParser = require('cookie-parser')var app = express()app.use(cookieParser())app.get('/', function(req, res) { console.log("Cookies: ", req.cookies)})app.listen(8081)Node.js RESTful API
- REST即表述性状态传递（英文：Representational State Transfer，简称REST）是Roy Fielding博士在2000年他的博士论文中提出来的一种软件架构风格。
- 表述性状态转移是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是RESTful。需要注意的是，REST是设计风格而不是标准。REST通常基于使用HTTP，URI，和XML（标准通用标记语言下的一个子集）以及HTML（标准通用标记语言下的一个应用）这些现有的广泛流行的协议和标准。REST 通常使用 JSON 数据格式。
- HTTP 方法
- 以下为 REST 基本架构的四个方法：
- GET - 用于获取数据。
- PUT - 用于更新或添加数据。
- DELETE - 用于删除数据。
- POST - 用于添加数据。
- 以下为 REST 基本架构的四个方法：
- 获取用户列表
var express = require('express');var app = express();var fs = require("fs");app.get('/listUsers', function (req, res) { fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) { console.log( data ); res.end( data ); });})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)})- 添加用户
var express = require('express');var app = express();var fs = require("fs");//添加的新用户数据var user = { "user4" : { "name" : "mohit", "password" : "password4", "profession" : "teacher", "id": 4 }}app.get('/addUser', function (req, res) { // 读取已存在的数据 fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) { data = JSON.parse( data ); data["user4"] = user["user4"]; console.log( data ); res.end( JSON.stringify(data)); });})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)})- 显示用户
var express = require('express');var app = express();var fs = require("fs");app.get('/:id', function (req, res) { // 首先我们读取已存在的用户 fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) { data = JSON.parse( data ); var user = data["user" + req.params.id] console.log( user ); res.end( JSON.stringify(user)); });})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)})- 删除用户
var express = require('express');var app = express();var fs = require("fs");var id = 2;app.get('/deleteUser', function (req, res) { // First read existing users. fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) { data = JSON.parse( data ); delete data["user" + 2]; console.log( data ); res.end( JSON.stringify(data)); });})var server = app.listen(8081, function () { var host = server.address().address var port = server.address().port console.log("应用实例，访问地址为 http://%s:%s", host, port)})Node.js 多进程
- 我们都知道 Node.js 是以单线程的模式运行的，但它使用的是事件驱动来处理并发，这样有助于我们在多核 cpu 的系统上创建多个子进程，从而提高性能。
- 每个子进程总是带有三个流对象：child.stdin, child.stdout 和child.stderr。他们可能会共享父进程的 stdio 流，或者也可以是独立的被导流的流对象。
- Node 提供了 child_process 模块来创建子进程，方法有：
- exec - child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。
- spawn - child_process.spawn 使用指定的命令行参数创建新进程。
- fork - child_process.fork 是 spawn()的特殊形式，用于在子进程中运行的模块，如 fork(‘./son.js’) 相当于 spawn(‘node’, [‘./son.js’]) 。与spawn方法不同的是，fork会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信。
- exec() 方法
- child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。
- 语法如下所示：
child_process.exec(command[, options], callback)
const fs = require('fs');const child_process = require('child_process');for(var i=0; i<3; i++) { var workerProcess = child_process.exec('node support.js '+i, function (error, stdout, stderr) { if (error) { console.log(error.stack); console.log('Error code: '+error.code); console.log('Signal received: '+error.signal); } console.log('stdout: ' + stdout); console.log('stderr: ' + stderr); }); workerProcess.on('exit', function (code) { console.log('子进程已退出，退出码 '+code); });}- spawn() 方法
- child_process.spawn 使用指定的命令行参数创建新进程，语法格式如下：
child_process.spawn(command[, args][, options])
- child_process.spawn 使用指定的命令行参数创建新进程，语法格式如下：
const fs = require('fs');const child_process = require('child_process');for(var i=0; i<3; i++) { var workerProcess = child_process.spawn('node', ['support.js', i]); workerProcess.stdout.on('data', function (data) { console.log('stdout: ' + data); }); workerProcess.stderr.on('data', function (data) { console.log('stderr: ' + data); }); workerProcess.on('close', function (code) { console.log('子进程已退出，退出码 '+code); });}- fork 方法
- child_process.fork 是 spawn() 方法的特殊形式，用于创建进程，语法格式如下：
child_process.fork(modulePath[, args][, options])
- child_process.fork 是 spawn() 方法的特殊形式，用于创建进程，语法格式如下：
const fs = require('fs');const child_process = require('child_process');for(var i=0; i<3; i++) { var worker_process = child_process.fork("support.js", [i]); worker_process.on('close', function (code) { console.log('子进程已退出，退出码 ' + code); });}Node.js 连接 MySQL
- select
var mysql = require('mysql');var connection = mysql.createConnection({ host : 'localhost', user : 'root', password : 'root', database : 'test'});connection.connect();var sql='select * from user';connection.query(sql, function (error, results) { if (error){ console.log("[select error]-",err.message); return; } console.log('---------select------------'); console.log('The solution is: ', results);});connection.end();- insert
var mysql = require('mysql');var connection = mysql.createConnection({ host : 'localhost', user : 'root', password : 'root', port : '3306', database : 'test',});connection.connect();var sql='insert into user(id,name) values(?,?)';var sqlParams = [4,'sdfa']connection.query(sql,sqlParams,function (error, result) { if (error){ console.log("[select error]-",err.message); return; } console.log('---------select------------'); console.log('The solution is: ', result);});connection.end();- update
var mysql = require('mysql');var connection = mysql.createConnection({ host : 'localhost', user : 'root', password : 'root', port : '3306', database : 'test',});connection.connect();var sql='update user set name=? where id=?';var sqlParams = ['你大招',4]connection.query(sql,sqlParams,function (error, result) { if (error){ console.log("[select error]-",err.message); return; } console.log('---------select------------'); console.log('The solution is: ', result);});connection.end();- delete
var mysql = require('mysql');var connection = mysql.createConnection({ host : 'localhost', user : 'root', password : 'root', port : '3306', database : 'test',});connection.connect();var sql='delete from user where id = ?';var sqlParams = [4]connection.query(sql,sqlParams,function (error, result) { if (error){ console.log("[select error]-",err.message); return; } console.log('---------select------------'); console.log('The solution is: ', result);});connection.end();阅读全文
0 0
- NodeJs学习笔记_01
- SQL学习笔记_01
- mysql 学习笔记_01
- MVC学习笔记_01
- Java学习笔记_01
- Vue学习笔记_01
- MySQL学习笔记_01
- Web学习笔记_01
- Hibernate3.32学习笔记_01
- Halcon学习笔记_01：Threshold
- Flex学习笔记_01 Flex简介
- Python学习笔记_01 环境构建
- Django学习笔记_01(视图及URL)
- nodejs 学习笔记--debug
- NodeJS学习笔记
- nodejs学习笔记
- nodeJs学习笔记
- nodejs学习笔记
- SpringMVC学习笔记
- 面试题：查询部门最高工资的员工信息
- 插件收集
- leetcode 410. Split Array Largest Sum
- 安卓RecyclerView的简单实用
- NodeJs学习笔记_01
- 计算一组离散数据的标准偏差和中位数。函数的构建
- ajax版员工分页查询
- leetcode349. Intersection of Two Arrays
- 根据经纬度判断车辆是否进度电子围栏
- iOS 7以上原生二维码、条码扫描（ZXingObjC相册读取）
- yii2显示当前controller和action的名字
- LR_protocol script_windows sockets
- 工具类：Time
