nodejs基礎

時間 2019-11-13

標籤 nodejs 基礎简体版

原文原文鏈接

Node.js 鏈接 MySQL
var mysql = require('mysql');
var connection = mysql.createConnection({
host : 'localhost',
user : 'root',
password : '123456',
port: '3306',
database: 'test',
});

connection.connect();
var addSql = 'INSERT INTO websites(Id,name,url,alexa,country) VALUES(0,?,?,?,?)';
var addSqlParams = ['工具', 'https://www.ysx.com','23453', 'CN'];
//增
connection.query(addSql,addSqlParams,function (err, result) {
if(err){
console.log('[INSERT ERROR] - ',err.message);
return;
}
console.log('-------------INSERT-------------');
//console.log('INSERT ID:',result.insertId);
console.log('INSERT ID:',result);
console.log('-------------------------\n\n');
});
connection.end();php

Node.js 多進程
Node.js 是以單線程的模式運行
事件驅動來處理併發
多核 cpu 的系統上建立多個子進程，從而提升性能
html

Node.js RESTful API
REST即表述性狀態傳遞
表述性狀態轉移是一組架構約束條件和原則。
REST是設計風格而不是標準。REST一般基於使用HTTP，URI，和XML（標準通用標記語言下的一個子集）以及HTML（標準通用標記語言下的一個應用）這些現有的普遍流行的協議和標準。REST 一般使用 JSON 數據格式。
HTTP 方法
如下爲 REST 基本架構的四個方法：
GET - 用於獲取數據。
PUT - 用於更新或添加數據。
DELETE - 用於刪除數據。
POST - 用於添加數據。 node

Node.js Express 框架
Express 是一個簡潔而靈活的 node.js Web應用框架, 提供了一系列強大特性幫助你建立各類 Web 應用，和豐富的 HTTP 工具。
使用 Express 能夠快速地搭建一個完整功能的網站。python

Express 框架核心特性：
能夠設置中間件來響應 HTTP 請求。
定義了路由表用於執行不一樣的 HTTP 請求動做。
能夠經過向模板傳遞參數來動態渲染 HTML 頁面。

安裝 Express
cnpm install express --savemysql

cnpm install body-parser --save
//處理 JSON, Raw, Text 和 URL 編碼的數據
cnpm install cookie-parser --save
//解析Cookie的工具,轉成對象
cnpm install multer --save
//enctype="multipart/form-data"（設置表單的MIME編碼）程序員

查看下 express 使用的版本號
cnpm list express

實例
var express = require('express');
var app = express();web

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)
})正則表達式

Node.js Web 模塊
Web服務器通常指網站服務器，是指駐留於因特網上某種類型計算機的程序，Web服務器的基本功能就是提供Web信息瀏覽服務。它只需支持HTTP協議、HTML文檔格式及URL，與客戶端的網絡瀏覽器配合。sql

大多數 web 服務器都支持服務端的腳本語言（php、python、ruby）等，並經過腳本語言從數據庫獲取數據，將結果返回給客戶端瀏覽器。shell

目前最主流的三個Web服務器是Apache、Nginx、IIS。

Node 建立 Web 服務器
var http = require('http');

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(8888);

// 控制檯會輸出如下信息
console.log('Server running at http://127.0.0.1:8888/');

Node.js 工具模塊
在 Node.js 模塊庫中有不少好用的模塊。
OS 模塊
提供基本的系統操做函數。
Path 模塊
提供了處理和轉換文件路徑的工具。
Net 模塊
用於底層的網絡通訊。提供了服務端和客戶端的的操做。
DNS 模塊
用於解析域名。
Domain 模塊
簡化異步代碼的異常處理，能夠捕捉處理try catch沒法捕捉的。

GET/POST請求
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);

// 解析 url 參數
var params = url.parse(req.url, true).query;
res.write("網站名：" + params.name);
res.write("\n");
res.write("網站 URL：" + params.url);

獲取 POST 請求內容
var http = require('http');
var util = require('util');
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);

//實例
var http = require('http');
var querystring = require('querystring');

var postHTML =
'<html><head><meta charset="utf-8"><title> ysx 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);

文件
讀取
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.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("文件打開成功！");
});

打開文件
fs.open(path, flags[, mode], callback)
path - 文件的路徑。
flags - 文件打開的行爲。具體值詳見下文。
mode - 設置文件模式(權限)，文件建立默認權限爲 0666(可讀，可寫)。
callback - 回調函數，帶有兩個參數如：callback(err, fd)。
Flag 描述
r 以讀取模式打開文件。若是文件不存在拋出異常。
r+ 以讀寫模式打開文件。若是文件不存在拋出異常。
rs 以同步的方式讀取文件。
rs+ 以同步的方式讀取和寫入文件。
w 以寫入模式打開文件，若是文件不存在則建立。
wx 相似 'w'，可是若是文件路徑存在，則文件寫入失敗。
w+ 以讀寫模式打開文件，若是文件不存在則建立。
wx+ 相似 'w+'，可是若是文件路徑存在，則文件讀寫失敗。
a 以追加模式打開文件，若是文件不存在則建立。
ax 相似 'a'，可是若是文件路徑存在，則文件追加失敗。
a+ 以讀取追加模式打開文件，若是文件不存在則建立。
ax+ 相似 'a+'，可是若是文件路徑存在，則文件讀取追加失敗。

獲取文件信息
fs.stat(path, callback)
path - 文件路徑。
callback - 回調函數，帶有兩個參數如：(err, stats), stats 是 fs.Stats 對象。

Node.js 經常使用工具
util 是一個Node.js 核心模塊，提供經常使用函數的集合，用於彌補核心JavaScript 的功能過於精簡的不足。
util.inherits(constructor, superConstructor)是一個實現對象間原型繼承的函數

var util = require('util');
function Base() {
this.name = 'base';
this.base = 1991;
this.sayHello = function() {
console.log('Hello ' + this.name);
};
}
Base.prototype.showName = function() {
console.log(this.name);
};
function Sub() {
this.name = 'sub';
}
util.inherits(Sub, Base);
var objBase = new Base();
objBase.showName();
objBase.sayHello();
console.log(objBase);
var objSub = new Sub();
objSub.showName();
//objSub.sayHello();
console.log(objSub);
Sub 僅僅繼承了Base 在原型中定義的函數，而構造函數內部創造的 base 屬性和 sayHello 函數都沒有被 Sub 繼承

util.isArray(object) //"object" 是一個數組返回true，不然返回false
util.isRegExp(object) // "object" 是一個正則表達式返回true，不然返回false
util.isDate(object) // "object" 是一個日期返回true，不然返回false
util.isError(object) // "object" 是一個錯誤對象返回true，不然返回false

Node.js 全局對象
在最外層定義的變量；
全局對象的屬性；
隱式定義的變量（未定義直接賦值的變量）

// 輸出全局變量 __filename 的值 __filename 表示當前正在執行的腳本的文件名
console.log(__filename);
// 輸出全局變量 __dirname 的值 __dirname 表示當前執行腳本所在的目錄
console.log( __dirname );

setTimeout(cb, ms)
clearTimeout(t);
setInterval(cb, ms)
clearInterval(t)

Node.js 路由
router1.js
var http = require("http");
var url = require("url");
function start() {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("router1 Hello ysx ");
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;

router2.js
function router(pathname) {
console.log("About to router a request for " + pathname);
}
exports.router = router;

router3.js
var router1 = require("./router1");
var router2 = require("./router2");
router1.start(router2.router);

Node.js 函數
JavaScript中，一個函數能夠做爲另外一個函數的參數
function say(word) {
console.log(word);
}
function execute(sameFunction, value) {
sameFunction(value);
}
execute(say, "ysx");
匿名函數
execute(function (ysx) {
console.log(ysx);
}, "ysx");
匿名函數的http服務器工做
var http = require("http");
http.createServer(function (request, response) {
response.writeHead(200, { "Content-Type": "text/plain" });
response.write("Hello ysx");
response.end();
}).listen(8888);

模塊系統
var hello = require('./hello');
hello.world();
//代碼 require('./hello') 引入了當前目錄下的 hello.js 文件

hello.js 文件，代碼以下：
exports.world = function() {
console.log('Hello World');
}

模塊引用
expres.js 文件
// exports.ysx = function(){
// console.log('hello ysx ');
// }
function ysx() {
var name;
this.setName = function (thyName) {
name = thyName;
};
this.sayHellow = function () {
console.log("Hellow " + name);
};
};
module.exports = ysx;
express.js 文件引用expres.js
//模塊
var hello = require("./expres");
// hello.ysx();
console.log(hello);
ysx = new hello();
ysx.setName("sxsx =");
ysx.sayHellow();

Node.js 中自帶了一個叫作 http 的模塊
var http = require("http");
http.createServer(...);

Node.js Stream(流)
Stream 是一個抽象接口，Node 中有不少對象實現了這個接口。例如，對http 服務器發起請求的request 對象就是一個 Stream，還有stdout（標準輸出）。

Stream 有四種流類型：
Readable - 可讀操做。
Writable - 可寫操做。
Duplex - 可讀可寫操做.
Transform - 操做被寫入數據，而後讀出結果。

全部的 Stream 對象都是 EventEmitter 的實例,事件有：
data - 當有數據可讀時觸發。
end - 沒有更多的數據可讀時觸發。
error - 在接收和寫入過程當中發生錯誤時觸發。
finish - 全部數據已被寫入到底層系統時觸發。
//讀取處理流事件 --> data,end,error/默認事件
var fs = require("fs");
var datas = "";
//建立可讀流
var readerStream = fs.createReadStream("input.txt");
//設置編碼格式 utf-8
readerStream.setEncoding("UTF8");
//處理流事件 --> data,end,error
readerStream.on("data", function (chunk) {
datas += chunk;
});
readerStream.on("end", function () {
console.log("end " + datas);
});
readerStream.on("error", function (err) {
console.log("error " + err.stack);
});
console.log("程序結束 ");

//寫入流 writerStream.write(datas, "UTF8");
var fs = require("fs");
var datas = "www.ysxsx.com";
//建立一個能夠寫入的流，寫入到文件
var writerStream = fs.createWriteStream("input.txt");
//寫入內容，編碼格式
writerStream.write(datas, "UTF8");
//標記文件末尾
writerStream.end();
// //處理事件 --> data,end,error
// writerStream.on("finish", function () {
// console.log("finish" + " 寫入完成。");
// });
// writerStream.on("error", function () {
// console.log("error" + err.stack);
// });
// console.log("程序執行完畢。");

管道流 (處理大文件)
管道提供了一個輸出流到輸入流的機制。一般咱們用於從一個流中獲取數據並將數據傳遞到另一個流中
實例：
var fs = require("fs");
var read = fs.createReadStream("input.txt");
var write = fs.createWriteStream("output.txt");
read.pipe(write);

鏈式流 (壓縮，多線程執行解壓)
鏈式是經過鏈接輸出流到另一個流並建立多個流操做鏈的機制。鏈式流通常用於管道操做
實例：
壓縮
var fs = require("fs");
var zlib = require('zlib');

// 壓縮 input.txt 文件爲 input.txt.gz
fs.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.txt
fs.createReadStream('input.txt.gz')
.pipe(zlib.createGunzip())
.pipe(fs.createWriteStream('input.txt'));
console.log("文件解壓完成。");

Node.js Buffer (緩衝區)
JavaScript 語言自身只有字符串數據類型，沒有二進制數據類型
在處理像TCP流或文件流時，必須使用到二進制數據。所以在 Node.js中，定義了一個 Buffer 類，該類用來建立一個專門存放二進制數據的緩存區
Buffer 類是隨 Node 內核一塊兒發佈的核心庫
在 Node.js 中處理I/O操做中移動的數據時，就有可能使用 Buffer 庫

const buf = Buffer.from("runoob", "ascii");//兩種數據編碼格式
console.log(buf.toString("hex"));
console.log(buf.toString('base64'));

Node.js 目前支持的字符編碼包括：
ascii - 僅支持 7 位 ASCII 數據。若是設置去掉高位的話，這種編碼是很是快的。
utf8 - 多字節編碼的 Unicode 字符。許多網頁和其餘文檔格式都使用 UTF-8 。
utf16le - 2 或 4 個字節，小字節序編碼的 Unicode 字符。支持代理對（U+10000 至 U+10FFFF）。
ucs2 - utf16le 的別名。
base64 - Base64 編碼。
latin1 - 一種把 Buffer 編碼成一字節編碼的字符串的方式。
binary - latin1 的別名。
hex - 將每一個字節編碼爲兩個十六進制字符。
Buffer 提供瞭如下 API 來建立 Buffer 類：

Buffer.alloc(size[, fill[, encoding]])：返回一個指定大小的 Buffer 實例，若是沒有設置 fill，則默認填滿 0
Buffer.allocUnsafe(size)：返回一個指定大小的 Buffer 實例，可是它不會被初始化，因此它可能包含敏感的數據
Buffer.allocUnsafeSlow(size)
Buffer.from(array)：返回一個被 array 的值初始化的新的 Buffer 實例（傳入的 array 的元素只能是數字，否則就會自動被 0 覆蓋）
Buffer.from(arrayBuffer[, byteOffset[, length]])：返回一個新建的與給定的 ArrayBuffer 共享同一內存的 Buffer。
Buffer.from(buffer)：複製傳入的 Buffer 實例的數據，並返回一個新的 Buffer 實例
Buffer.from(string[, encoding])：返回一個被 string 的值初始化的新的 Buffer 實例
// 建立一個長度爲十、且用 0 填充的 Buffer。
const buf1 = Buffer.alloc(10);
// 建立一個長度爲十、且用 0x1 填充的 Buffer。
const buf2 = Buffer.alloc(10, 1);
// 建立一個長度爲十、且未初始化的 Buffer。
// 這個方法比調用 Buffer.alloc() 更快，
// 但返回的 Buffer 實例可能包含舊數據，
// 所以須要使用 fill() 或 write() 重寫。
const buf3 = Buffer.allocUnsafe(10);
// 建立一個包含 [0x1, 0x2, 0x3] 的 Buffer。
const buf4 = Buffer.from([1, 2, 3]);
// 建立一個包含 UTF-8 字節 [0x74, 0xc3, 0xa9, 0x73, 0x74] 的 Buffer。
const buf5 = Buffer.from('tést');
// 建立一個包含 Latin-1 字節 [0x74, 0xe9, 0x73, 0x74] 的 Buffer。
const buf6 = Buffer.from('tést', 'latin1');

寫入 Node 緩衝區的語法以下
buf.write(string[, offset[, length]][, encoding])
參數描述以下：
string - 寫入緩衝區的字符串。
offset - 緩衝區開始寫入的索引值，默認爲 0 。
length - 寫入的字節數，默認爲 buffer.length
encoding - 使用的編碼。默認爲 'utf8' 。
返回值
返回實際寫入的大小。若是 buffer 空間不足，則只會寫入部分字符串
讀取 Node 緩衝區數據的語法以下
buf.toString([encoding[, start[, end]]])
參數描述以下：
encoding - 使用的編碼。默認爲 'utf8' 。
start - 指定開始讀取的索引位置，默認爲 0。
end - 結束位置，默認爲緩衝區的末尾。
實例
buf = Buffer.alloc(26);
for (var i = 0 ; i < 26 ; i++) {
buf[i] = i + 97;
}
console.log( buf.toString('ascii')); // 輸出: abcdefghijklmnopqrstuvwxyz
console.log( buf.toString('ascii',0,5)); // 輸出: abcde
console.log( buf.toString('utf8',0,5)); // 輸出: abcde
console.log( buf.toString(undefined,0,5)); // 使用 'utf8' 編碼, 並輸出: abcde

將 Node Buffer 轉換爲 JSON 對象的函數語法格式
buf.toJSON()
字符串化一個 Buffer 實例時，JSON.stringify() 會隱式地調用該 toJSON()
實例
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);

// 輸出: {"type":"Buffer","data":[1,2,3,4,5]}
console.log(json);

const copy = JSON.parse(json, (key, value) => {
return value && value.type === 'Buffer' ?
Buffer.from(value.data) :
value;
});
// 輸出: <Buffer 01 02 03 04 05>
console.log(copy);
緩衝區合併
語法
Node 緩衝區合併的語法以下所示：
Buffer.concat(list[, totalLength])
參數
list - 用於合併的 Buffer 對象數組列表。
totalLength - 指定合併後Buffer對象的總長度。

返回值
返回一個多個成員合併的新 Buffer 對象。

實例
var buffer1 = Buffer.from(('YSX'));
var buffer2 = Buffer.from(('www.YSX.com'));
var buffer3 = Buffer.concat([buffer1,buffer2]);
console.log("buffer3 內容: " + buffer3.toString());
執行以上代碼，輸出結果爲：
buffer3 內容: YSXwww.YSX.com

返回值
解碼緩衝區數據並使用指定的編碼返回字符串。

緩衝區比較
buf.compare(otherBuffer);//otherBuffer - 與 buf 對象比較的另一個 Buffer 對象
返回值
返回一個數字，表示 buf 在 otherBuffer 以前，以後或相同
eg:
var buffer1 = Buffer.from('ABC');
var buffer2 = Buffer.from('ABCD');
var result = buffer1.compare(buffer2);

if(result < 0) {
console.log(buffer1 + " 在 " + buffer2 + "以前");
}else if(result == 0){
console.log(buffer1 + " 與 " + buffer2 + "相同");
}else {
console.log(buffer1 + " 在 " + buffer2 + "以後");
}
拷貝緩衝區
buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]])
參數
targetBuffer - 要拷貝的 Buffer 對象。
targetStart - 數字, 可選, 默認: 0
sourceStart - 數字, 可選, 默認: 0
sourceEnd - 數字, 可選, 默認: buffer.length
返回值
沒有返回值。
實例拷貝插入
var buf1 = Buffer.from('abcdefghijkl');
var buf2 = Buffer.from('RUNOOB');
//將 buf2 插入到 buf1 指定位置上 abRUNOOBijkl
buf2.copy(buf1, 2);
console.log(buf1.toString());
執行以上代碼，輸出結果爲： abRUNOOBijkl

緩衝區裁剪
buf.slice([start[, end]])
參數
start - 數字, 可選, 默認: 0
end - 數字, 可選, 默認: buffer.length
返回值
返回一個新的緩衝區，它和舊緩衝區指向同一塊內存，可是從索引 start 到 end 的位置剪切
實例
var buffer1 = Buffer.from('runoob');
// 剪切緩衝區
var buffer2 = buffer1.slice(0,2);
console.log("buffer2 content: " + buffer2.toString());
執行以上代碼，輸出結果爲：
buffer2 content: ru
緩衝區長度
buf.length;

Events
addListener(event, listener)
爲指定事件添加一個監聽器到監聽器數組的尾部。
2 on(event, listener)
爲指定事件註冊一個監聽器，接受一個字符串 event 和一個回調函數。
server.on('connection', function (stream) {
console.log('someone connected!');
});
3 once(event, listener)
爲指定事件註冊一個單次監聽器，即監聽器最多隻會觸發一次，觸發後馬上解除該監聽器。
server.once('connection', function (stream) {
console.log('Ah, we have our first user!');
});
4 removeListener(event, listener)
移除指定事件的某個監聽器，監聽器必須是該事件已經註冊過的監聽器。

它接受兩個參數，第一個是事件名稱，第二個是回調函數名稱。

var callback = function(stream) {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
5 removeAllListeners([event])
移除全部事件的全部監聽器，若是指定事件，則移除指定事件的全部監聽器。
6 setMaxListeners(n)
默認狀況下， EventEmitters 若是你添加的監聽器超過 10 個就會輸出警告信息。 setMaxListeners 函數用於提升監聽器的默認限制的數量。
7 listeners(event)
返回指定事件的監聽器數組。
8 emit(event, [arg1], [arg2], [...])
按參數的順序執行每一個監聽器，若是事件有註冊監聽返回 true，不然返回 false。

類方法
events.emitter.listenerCount(eventName) //推薦
事件
1 newListener
event - 字符串，事件名稱
listener - 處理事件函數

該事件在添加新監聽器時被觸發。

2 removeListener
event - 字符串，事件名稱
listener - 處理事件函數

從指定監聽器數組中刪除一個監聽器。須要注意的是，此操做將會改變處於被刪監聽器以後的那些監聽器的索引。
eg：
var events = require("events");
var eventEmitter = new events.EventEmitter();
var listener1 = function listener1() {
console.log("監聽 1 =");
}
var listener2 = function listener2() {
console.log("監聽 2 =");
}
//綁定 connection 事件處理函數
eventEmitter.addListener("connection", listener1);
eventEmitter.on("connection", listener2);
var eventEmitters = eventEmitter.listenerCount("connection");
console.log(eventEmitters + " 個監聽器監聽鏈接事件");
//處理conncction事件
eventEmitter.emit("connection");
//移出綁定的 listener1 函數
eventEmitter.removeListener("connection", listener1);
console.log("listener1 再也不受監聽。");
// 觸發鏈接事件
eventEmitter.emit('connection');
eventListeners = eventEmitter.listenerCount('connection');
console.log(eventListeners + " 個監聽器監聽鏈接事件。");

事件驅動 emit on 事件綁定
EventEmitters ->Event -><- Event Loop ->Event Handleers
引入 events 模塊
var events = require("events");
建立 eventEmitter 對象
var eventEmitter = new events.EventMitter();
綁定事件處理程序：
eventEmitter.on('eventName',eventHandler);
經過程序觸發
eventEmitter.emit("eventName");

Node.js 事件循環
Node.js 是單進程單線程應用程序，V8提供的異步執行回調接口，處理大量併發，高性能
Node.js幾乎每一個API都支持回調函數
Node.js 基本上全部事件機制都是觀察者模式實現
Node.js 單線程相似進入一個while(true)的事件循環，直到沒有事件觀察者退出，每一個異步事件都生成一個事件觀察者，若是事件發生就調用該回調函數

Node.js 回調函數
node.js 異步編程的直接體現就是回調
回調函數通常做爲函數的最後一個參數出現
function test1(name,age,callback1,callback2){}
阻塞代碼等待讀取文件完以後，繼續執行以後命令
var fs = require("fs");
var data = fs.readFileSync("input.txt");
console.log("讀取input.txt內容: " + data.toString());
（回調）非阻塞代碼異步，無需等待讀取文件，與輸出各自執行
var fss = require("fs");
var datas = fss.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
} console.log("讀取input.txt內容: " + data.toString());
});

Node.js REPL(交互式解釋器)
(Read Eval Print Loop:交互式解釋器)表示一個電腦環境，相似Window系統終端或者Unix/Linux shell。能夠再終端輸入命令，接收系統的響應。

啓動Node終端命令：
node
終端REPL 命令：
REPL 命令
ctrl + c - 退出當前終端。
ctrl + c 按下兩次 - 退出 Node REPL。
ctrl + d - 退出 Node REPL.
向上/向下鍵 - 查看輸入的歷史命令
tab 鍵 - 列出當前命令
.help - 列出使用命令
.break - 退出多行表達式
.clear - 退出多行表達式
.save filename - 保存當前的 Node REPL 會話到指定文件
.load filename - 載入當前 Node REPL 會話的文件內容。
//··

若是舊版本的npm 升級
sudo npm install npm -g
window 系統命令：
npm install npm -g
淘寶鏡像命令：
cnpm install npm -g

查看安裝信息
npm list
npm list -g #全局

npm 命令安裝Node.js web框架模塊express:
npm install express # 本地安裝
npm install express -g # 本地安裝(global)
若是出現如下錯誤：
npm err! Error: connect ECONNREFUSED 127.0.0.1:8087
解決辦法爲：
$ npm config set proxy null

Node.js 三部分組成
1 引入 required模塊：使用 require 指令來載入 Node.js 模塊。
2 建立服務器：服務器能夠監聽客戶端的請求，相似於Apache、Njinx、等HTTP服務器
3 接受請求與響應式請求服務器很容易建立，客戶端可使用瀏覽器或終端發送Http請求，服務器接收請求後返回請求數據
步驟一引入required模塊
var http = required("http");//實例化http賦值給變量http
步驟二建立服務器：服務器能夠監聽客戶端的請求，相似於Apache、Njinx、等HTTP服務器

node test.js //執行test.js文件

Node 版本，命令行：
node -v

想建立本身的服務，那Node.js能夠勝任後端程序員，想部署一些高性能的服務，那麼Node.js也行

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。