1. nodejs 中express框架中request有哪些屬性和方法
最近本人在學習開發NodeJs，使用到express框架，對於網上的學習資料甚少，因此本人會經常在開發中做一些總結。
express獲取參數有三種方法：官網介紹如下
Checks route params (req.params), ex: /user/:id
Checks query string params (req.query), ex: ?id=12
Checks urlencoded body params (req.body), ex: id=
1、例如：127.0.0.1:3000/index，這種情況下，我們為了得到index，我們可以通過使用req.params得到，通過這種方法我們就可以很好的處理Node中的路由處理問題，同時利用這點可以非常方便的實現MVC模式；
2、例如：127.0.0.1:3000/index?id=12，這種情況下，這種方式是獲取客戶端get方式傳遞過來的值，通過使用req.query.id就可以獲得，類似於PHP的get方法；
3、例如：127.0.0.1：300/index，然後post了一個id=2的值，這種方式是獲取客戶端post過來的數據，可以通過req.body.id獲取，類似於PHP的post方法；
下面舉例介紹下這三個方法：
如下一個test.html代碼
<form action="/index" method="get">
<input type="text" name="login_name"/>
<input type="submit" value="Sign In" />
</form>
在nodeJs中我們要自定義HTTP，因此創建index.js
var app = require('express').createServer();
app.get('/:key', function(req, res){
console.log(req.params.key);//輸出index
console.log(req.query.login_name);//輸出表單get提交的login_name
res.send('great you are right for get method!');//顯示頁面文字信息
});
app.post('/:key', function(req, res){
<pre name="code" class="javascript"> console.log(req.params.key);//輸出index
console.log(req.body.login_name);//輸出表單post提交的login_name
res.send('great you are right for post method!');//顯示頁面文字信息
});app.listen(3000);
之後運行node index.js就可以看到本效果，當然前提是你要先訪問test.html，至於如何通過express訪問一個html文件我就不詳細描述了，可以參考如下代碼：
global.fs=require('fs');
var realpath = VIEW + "test.html";
var file = fs.readFileSync(realpath);
res.end(file);
2. nodejs 怎麼獲取post請求的json數據
前端傳給伺服器的只是json 格式的字元串，使用json_decode，
mixed json_decode ( string $json [, bool $assoc ] )
var_mp(json_decode($json));
var_mp(json_decode($json, true));
如果不帶參數，則返回版為對象
帶上true時，返回數組
foreach($ARR as $k=>$v){
echo 'key='.$k.';value='.$v;
}
單獨處理每個key 和對權應的value就好
3. node JS中處理json字元串中含有轉義符號\ ，不能解析成json對象
使用JSON從後台向前台傳輸數據的時候，當數據本身含有一些特殊字元，會導致數據的解析出錯。
使用下面的方法對即將向前台輸出的json字元串進行處理，可以解決鍵盤上能輸入的所有特殊字元問題。
//當文本中含有如下特殊字元時，此方法可以成功處理，讓其在前台被正確解析，注意：此法不能處理單引號
public static String stringToJson(String s) {
StringBuffer sb = new StringBuffer ();
for (int i=0; i<s.length(); i++) {
char c = s.charAt(i);
switch (c) {
case '\"':
sb.append("\\\"");
break;
// case '\\': //如果不處理單引號，可以釋放此段代碼，若結合下面的方法處理單引號就必須注釋掉該段代碼
// sb.append("\\\\");
// break;
case '/':
sb.append("\\/");
break;
case '\b': //退格
sb.append("\\b");
break;
case '\f': //走紙換頁
sb.append("\\f");
break;
case '\n':
sb.append("\\n"); //換行
break;
case '\r': //回車
sb.append("\\r");
break;
case '\t': //橫向跳格
sb.append("\\t");
break;
default:
sb.append(c);
}}
return sb.toString();
}
//注意，下面的方法是在把你的數據文本接入json數據字元串之前使用，預先對文本做處理後在接入JSON字元串
//處理文本中的單引號 和 斜杠
public static String StringDanYinToJSON(String ors) {
ors = ors == null ? "" : ors;
StringBuffer buffer = new StringBuffer(ors);
int i = 0;
while (i < buffer.length()) {
if (buffer.charAt(i) == '\'' || buffer.charAt(i) == '\\') {
buffer.insert(i, '\\');
i += 2;
} else {
i++;
}
}
return buffer.toString();
}
4. nodejs的readline怎麼支持字元串逐行讀取
nodejs 可以 直接 require JSON文件的....跟require JS文件一樣
我想把資料庫相關的地址埠，賬號密碼等等寫到一個json文件里專，然後node從json里讀取
我用的屬mongoskin，我現在是在代碼里寫死的，比如：
var db = require('mongoskin').db('root:123@localhost:27017/xxxx');
如果要讀json的話，要用fs模塊，然後
var db;
fs.readFile(json , function(err,data)) {
db = ......
}
5. nodejs編譯後js文件名前綴
Node.js 是一個基於 Chrome V8 引擎的 JavaScript 運行環境。
Node與javaScript的區別在於，javaScript的頂層對象是window,而node是global
//這里使用的var聲明的變數不是全局的，是當前模塊下的，用global聲明的表示是全局的
var s = 100;
global.s = 200;
//這里訪問到的s是var生命的
console.log(s); //100
//這里訪問到的才是全局變數
console.log(global.s); //200
模塊：在node中，文件和模塊是一一對應的，也就是一個文件就是一個模塊；每個模塊都有自己的作用域，我們通過var申明的變數並非全局而是該模塊作用域下的。
（2）mole模塊
1、文件查找
1）首先按照載入的模塊的文件名稱進行查找，如果沒有找到，則會帶上 .js、.json 或 .node 拓展名在載入
2）以 '/' 為前綴的模塊是文件的絕對路徑。 例如，require('/home/marco/foo.js') 會載入 /home/marco/foo.js 文件。
3）以 './' 為前綴的模塊是相對於調用 require() 的文件的。 也就是說，circle.js 必須和 foo.js 在同一目錄下以便於 require('./circle') 找到它。
4）當沒有以 '/'、'./' 或 '../' 開頭來表示文件時，這個模塊必須是一個核心模塊或載入自 node_moles 目錄。
5）如果給定的路徑不存在，則 require() 會拋出一個 code 屬性為 'MODULE_NOT_FOUND' 的 Error。
2、mole 作用域
在一個模塊中通過var定義的變數，其作用域范圍是當前模塊，外部不能夠直接的訪問，如果我們想一個模塊能夠訪問另外一個模塊中定義的變數，可以有一下兩種方式：
1）把變數作為global對象的一個屬性，但這樣的做法是不推薦的
2）使用模塊對象 mole。mole保存提供和當前模塊有關的一些信息。
在這個mole對象中有一個子對象exports對象，我們可以通過這個對象把一個模塊中的局部變數對象進行提供訪問。
//這個方法的返回值，其實就是被載入模塊中的mole.exports
require('./02.js');
3、__dirname：當前模塊的目錄名。
例子，在 /Users/mjr 目錄下運行 node example.js：
console.log(__dirname);
// 輸出: /Users/mjr
console.log(path.dirname(__filename));
// 輸出: /Users/mjr
4、__filename：當前模塊的文件名（處理後的絕對路徑）。當前模塊的目錄名可以使用 __dirname 獲取。
在 /Users/mjr 目錄下運行 node example.js：
console.log(__filename);
// 輸出: /Users/mjr/example.js
console.log(__dirname);
// 輸出: /Users/mjr
（3）process（進程）
process 對象是一個全局變數，提供 Node.js 進程的有關信息以及控制進程。 因為是全局變數，所以無需使用 require()。
1、process.argv
返回進程啟動時的命令行參數。第一個元素是process.execPath。第二個元素是當前執行的JavaScript文件的路徑。剩餘的元素都是額外的命令行參數。
console.log(process.argv);
列印結果：
2、process.execPath返回啟動進程的可執行文件的絕對路徑。
3、process.env 返回用戶的環境信息。
在process.env中可以新增屬性：
process.env.foo = 'bar';
console.log(process.env.foo);
可以通過delete刪除屬性：
delete process.env.foo;
console.log(process.env);
在Windows上，環境變數不區分大小寫
4、process.pid 屬性返回進程的PID。
5、process.platform屬性返回字元串，標識Node.js進程運行其上的操作系統平台。
6、process.title 屬性用於獲取或設置當前進程在 ps 命令中顯示的進程名字
7、process.uptime() 方法返回當前 Node.js 進程運行時間秒長
注意: 該返回值包含秒的分數。 使用 Math.floor() 來得到整秒鍾。
8、process.versions屬性返回一個對象，此對象列出了Node.js和其依賴的版本信息。
process.versions.moles表明了當前ABI版本，此版本會隨著一個C++API變化而增加。 Node.js會拒絕載入模塊，如果這些模塊使用一個不同ABI版本的模塊進行編譯。
9、process對象-輸入輸出流
var a;
var b;
process.stdout.write('請輸入a的值: ');
process.stdin.on('data', (chunk) => {
if (!a) {
a = Number(chunk);
process.stdout.write('請輸入b的值:');
}else{
b = Number(chunk);
process.stdout.write('a+b的值:'+(a+b));
process.exit();
}
});
（4）Buffer緩沖器
Buffer類，一個用於更好的操作二進制數據的類，我們在操作文件或者網路數據的時候，其實操作的就是二進制數據流，Node為我們提供了一個更加方便的去操作這種數據流的類Buffer,他是一個全局的類
1、如何創建使用buffer
Buffer.from(array) 返回一個 Buffer，包含傳入的位元組數組的拷貝。
Buffer.from(arrayBuffer[, byteOffset [, length]]) 返回一個 Buffer，與傳入的 ArrayBuffer 共享內存。
Buffer.from(buffer) 返回一個 Buffer，包含傳入的 Buffer 的內容的拷貝。
Buffer.from(string[, encoding]) 返回一個 Buffer，包含傳入的字元串的拷貝。
Buffer.alloc(size[, fill[, encoding]]) 返回一個指定大小且已初始化的 Buffer。 該方法比 Buffer.allocUnsafe(size) 慢，但能確保新創建的 Buffer 不會包含舊數據。
Buffer.allocUnsafe(size) 與 Buffer.allocUnsafeSlow(size) 返回一個指定大小但未初始化的 Buffer。 因為 Buffer 是未初始化的，可能包含舊數據。
// 創建一個長度為 10、且用 01 填充的 Buffer。
const buf1 = Buffer.alloc(10,1);
// 創建一個長度為 10、且未初始化的 Buffer。
// 這個方法比調用 Buffer.alloc() 更快，但返回的 Buffer 實例可能包含舊數據，因此需要使用 fill() 或 write() 重寫。
const buf2 = Buffer.allocUnsafe(10);
const buf3 = Buffer.from([1, 2, 3]);
const buf4 = Buffer.from('tést');
console.log(buf1); //<Buffer 01 01 01 01 01 01 01 01 01 01>
console.log(buf2); //<Buffer 00 00 00 00 08 00 00 00 07 00>
console.log(buf3); //<Buffer 01 02 03>
console.log(buf4); //<Buffer 74 c3 a9 73 74>
2、Buffer對象提供的toString、JSON的使用
1）buf.toString(encoding，start，end)
var bf = Buffer.from('miaov');
console.log(bf.toString('utf-8',1,4)); //iaov
console.log(bf.toString('utf-8',0,5)); //miaov
console.log(bf.toString('utf-8',0,6)); //miaov
2）buf.write(string，offset，length，encoding)
string 要寫入 buf 的字元串。
offset 開始寫入的偏移量。默認 0，這里指的是buffer對象的起始要寫入的位置。
length 要寫入的位元組數。默認為 buf.length - offset。
encoding string 的字元編碼。默認為 'utf8'。
返回: 已寫入的位元組數。
var str = "miaov hello";
var bf = Buffer.from(str);
var bf2 = Buffer.alloc(8);
//從0開始寫入5個
bf2.write(str,0,5);
console.log(bf);
console.log(bf2);
3）buf.toJSON()
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);
console.log(json);
// 輸出: {"type":"Buffer","data":[1,2,3,4,5]}
3、Buffer中靜態方法的使用
1）Buffer.isEncoding(encoding) ： 判斷是否是Buffer支持的字元編碼，是則返回true，不是則返回false
console.log(Buffer.isEncoding('utf-8')); //true
2）Buffer.isBuffer(obj) ：如果 obj 是一個 Buffer，則返回 true，否則返回 false。
（5）fs（文件系統）
該模塊是核心模塊，需要使用require('fs')導入後使用，該模塊主要用來操作文件
1、fs.open(path, flags, mode, callback)
path：要打開的文件的路徑；
flags：打開文件的方式 讀/寫；
mode：設置文件的模式 讀/寫/執行
callback(err，fd)：文件打開以後，在回調函數中做相應的處理,回調函數的兩個參數：
err：文件打開失敗的錯誤保存在err裡面，如果成功err為null
fd：被打開文件的標識
var fs = require('fs');
fs.open('./test.txt','r',function(err,fd){
if(err){
console.log("文件打開失敗");
}else{
console.log("文件打開成功");
}
});
2、fs.openSync(path, flags, mode) ：返迴文件描述符。
var fs = require('fs');
console.log(fs.openSync('./test.txt','r')); //3
3、fs.read(fd, buffer, offset, length, position, callback)
從 fd 指定的文件中讀取數據；
buffer 指定要寫入數據的 buffer；
offset 指定 buffer 中開始寫入的偏移量；
length 指定要讀取的位元組數；
position 指定文件中開始讀取的偏移量。 如果 position 為 null，則從文件的當前位置開始讀取；
callback 有三個參數 (err, bytesRead, buffer)
示例：test.txt 中的值為123456789
fs.open('./test.txt','r',function(err,fd){
if(!err){
var bf = Buffer.alloc(5);
fs.read(fd,bf,0,5,0,function(){
console.log(bf.toString()); //12345
})
}
});
4、fs.write(fd, buffer, offset, length, position, callback)
將 buffer 寫入到 fd 指定的文件。
offset 指定 buffer 中要開始被寫入的偏移量，length 指定要寫入的位元組數。
position 指定文件中要開始寫入的偏移量。 如果 typeof position !== 'number'，則從當前位置開始寫入。
callback 有三個參數 (err, bytesWritten, buffer)，其中 bytesWritten 指定 buffer 中已寫入文件的位元組數。
var fs = require('fs');
fs.open('./test.txt','r+',function(err,fd){
if(!err){
var bf = Buffer.alloc(5);
fs.read(fd,bf,0,5,0,function(){
console.log(bf.toString()); //12345
});
var bf = Buffer.from('test數據');
fs.write(fd,bf,0,10,0);
fs.write(fd,'測試數據2',10,'utf-8');
}
});
fs.write(fd, string, position, encoding, callback)
將 string 寫入到 fd 指定的文件。 如果 string 不是一個字元串，則會強制轉換成字元串。
position 指定文件中要開始寫入的偏移量。 如果 typeof position !== 'number'，則從當前位置開始寫入。
encoding 指定字元串的編碼。
callback 有三個參數 (err, written, string)，其中 written 指定字元串中已寫入文件的位元組數。 寫入的位元組數與字元串的字元數是不同的。
5、fs.exists(path,callback)檢查指定路徑的文件或者目錄是否存在
fs.appendFile(path, data, callback)：將數據追加到文件，如果文件不存在則創建文件。
//檢查文件是否存在
var fs = require('fs');
var filename = './test2.txt';
fs.exists(filename,function(isExists){
if(!isExists){
fs.writeFile(filename,'miaov',function(err){
if(err){
console.log("文件創建失敗");
}else{
console.log("文件創建成功");
}
});
}else{
fs.appendFile(filename,'-leo',function(err){
if(err){
console.log("文件內容追加失敗");
}else{
console.log("文件內容追加成功");
}
})
}
});
（6）前端項目自動化構建
1、創建myProject項目文件以及對應的文件夾
var projectData ={
'name':'myProject',
'fileData':[
{
'name':'css',
'type':'dir'
},{
'name':'js',
'type':'dir'
},{
'name':'images',
'type':'dir'
},{
'name':'index.html',
'type':'file',
'content' : '<html>\n\t<head>\n\t\t<title>title</title>\n\t</head>\n\t<body>\n\t\t<h1>Hello</h1>\n\t</body>\n</html>'
}
]
};
var fs = require('fs');
if(projectData.name){
// 創建項目文件夾
fs.mkdirSync(projectData.name);
var fileData = projectData.fileData;
if(fileData && fileData.length){
fileData.forEach(function(file){
//文件或文件夾路徑
file.path = './'+projectData.name +'/'+ file.name;
//根據type類型創建文件或文件夾
file.content = file.content || '';
switch(file.type){
case 'dir':
fs.mkdirSync(file.path);
break;
case 'file':
fs.writeFileSync(file.path,file.content);
break;
default:
break;
}
});
}
}
2、自動打包多個文件
var fs = require('fs');
var filedir = './myProject/dist';
fs.exists(filedir,function(isExists){
if(!isExists){
fs.mkdirSync(filedir);
}
fs.watch(filedir,function(ev,file){
//只要有一個文件發生了變化，我們就需要對文件夾下的所有文件進行讀取、合並
fs.readdir(filedir,function(err,dataList){
var arr = [];
dataList.forEach(function(file){
if(file){
//statSync查看文件屬性
var info = fs.statSync(filedir + '/' +file);
//mode文件許可權
if(info.mode === 33206){
arr.push(filedir + '/' +file);
}
}
});
//讀取數組中的文件內容
var content = '';
arr.forEach(function(file){
var c = fs.readFileSync(file);
content += c.toString()+'\n';
});
//合並文件中的內容
fs.writeFileSync('./myProject/js/index.js',content);
})
});
});
（7）使用node進行web開發
1、搭建一個http的伺服器，用於處理用戶發送的http請求
//載入一個http模塊
var http = require('http');
//通過http模塊下的createServer創建並返回一個web伺服器對象
var server = http.createServer();
//開啟 HTTP 伺服器監聽連接，只有調用了listen方法以後，伺服器才開始工作
server.listen(8000,'localhost');
//伺服器是否正在監聽連接
server.on('listening',function(){
console.log("listening..........");
});
//每次接收到一個請求時觸發，每個連接可能有多個請求（在 HTTP keep-alive 連接的情況下）。
server.on('request',function(){
res.write('<p>hello</p>');
res.end();
});
2、request方法有兩個參數：request、response
1）request：http.IncomingMessage的一個實例，獲取請求的一些信息，如頭信息，數據等
httpVession：使用的http協議的版本
headers：請求頭信息中的數據
url：請求的地址
method：請求的方式
2）response：http.ServerResponse的一個實例，可以向請求的客戶端輸出返回響應
write（chunk,encoding）：發送一個數據塊到相應正文中
end（chunk,encoding）：當所有的正文和頭信息發送完成以後調用該方法告訴伺服器數據已經全部發送完成了，這個方法在每次完成信息發送以後必須調用，並且是最後調用。
statusCode：該屬性用來設置返回的狀態碼
setHeader（name,value）：設置返回頭信息
writeHead（statusCode,reasonPhrase,headers）這個方法只能在當前請求中使用一次，並且必須在response.end（）之前調用
3、使用fs模塊實現行為表現分離
var http = require('http');
var url = require('url');
var fs = require('fs');
var server = http.createServer();
//html文件的路徑
var htmlDir = __dirname + '/html/';
server.on('request',function(request,response){
var urlStr = url.parse(request.url);
//根據pathname匹配對應的html文件
switch(urlStr.pathname){
case '/':
sendData(htmlDir + 'index.html',request,response);
break;
case '/user':
sendData(htmlDir + 'user.html',request,response);
break;
case '/login':
sendData(htmlDir + 'login.html',request,response);
break;
default:
//處理其他情況
sendData(htmlDir + 'err.html',request,response );
break;
}
});
function sendData(file,request,response){
//讀取文件，存在則返回對應讀取的內容，不存在則返回錯誤信息
fs.readFile(file,function(err,data){
if(err){
response.writeHead(404,{
'content-type':'text/html;charset=utf-8'
});
response.end('<h1>頁面不存在</h1>')
}else{
response.writeHead(200,{
'content-type':'text/html;charset=utf-8'
});
response.end(data);
}
})
}
server.listen(8000,'localhost');
6. Node.js的Buffer與字元編碼及轉換
Buffer實例一般用於表示編碼字元的序列，如UTF-8、UCS2、Base64或十六進制編碼的數據。通過使用顯式的字元編碼就可以在Buffer實例與普通的JavaScript字元串之間進行相互轉換。
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：將每個位元組編碼為兩個十六進制字元昌姿。
7. node.js怎麼把數據存入資料庫
nodejs數據存mongodb：
首先創建資料庫保存用戶信息
資料庫創建名 users 集合並插入條用戶信息前沒 users 集合mongodb 直接創建
> db.users.insert( { "userId":1, "name":"tom", "email":"[email protected]" })
查找信息使用 find 或者 findOne區別於 findOne 返結
db.users.findOne( {"userId": 1})
返結：
{
"_id" : ObjectId("5413be6e9e1c9f9c4386756d"),
"userId" : 1,
"name" : "tom",
"email" : "[email protected]"
}
驅程序
編輯 package.json, 添加於 mongodb 引用
{
"name": "express-api",
"version": "0.0.1",
"dependencies": {
"express": "2.5.9",
"ejs": "0.4.2",
"mongodb": "1.4.1"
}
}
重新 npm install 安裝 mongodb 驅
使用 MongoDB 資料庫
修改代碼首先 require mongodb 模塊連接 mongodb 資料庫
var mongo = require("mongodb");
var express = require("express");
var app = express.createServer();
app.set("view engine", "ejs");
app.set("views", __dirname + "/views");
app.set("view options", { layout: false });
app.get("/", function (request, response) {
response.render("index");
});
app.get("/user/:id", function (request, response) {
var id = request.params.id;
console.log(id);
app.users.findOne({ "userId": +id }, function (error, doc) {
if (error) return next(error);
response.json(doc);
});
});
// connect mongodb
var server = new mongo.Server("127.0.0.1", 27017);
var db = new mongo.Db("members", server, {safe:true }).open(function (error, client) {
if (error) throw error;
console.log("\033[96m + \033[39m connected to mongodb");
app.users = new mongo.Collection(client, "users");
client.ensureIndex("users", "userId", function (error) {
if (error) throw error;
console.log("\033[96m + \033[39m ensured index.");
console.log("Web Server listening ......");
app.listen(3000);
});
});
注意現資料庫查找用戶id 前面 + 用表單字元串類型數據轉換需要數字類型
app.users.findOne({ "userId": +id }, function (error, doc) {
if (error) return next(error);
response.json(doc);
});
8. nodejs怎麼獲取它所在機器的locale和字元編碼
列印頭信息就可以了，因為nodejs是基於HTTP流編程的，
在頭信息中找到Accept-Language就是當地的瀏覽器設備支持的編碼了。
這個說應該明白了吧