module和exports
1 /* 2 * module和exports 3 * 4 * 在一個模塊中通過val定義的變量，其作用域范圍是當前模塊，外部不能夠直接的訪問 5 * 如果我們想一個模塊能夠訪問另外一個模塊中定義的變量，有如下方式： 6 */ 7 8 9 /* 10 * 1.把變量作為global對象的一個屬性，但是這樣的做法不推薦 11 */ 12 global.a = 100; 13 console.log(global.a); 14 15 /* 16 * 2.使用模塊對象 module 17 * 18 * module: 保存提供和當前模塊有關的一些信息 19 * 20 * 在這個module對象，有一個子對象：exports對象 21 * 我們可以通過這個對象把一個模塊中的局部變量對象進行提供訪問 22 */ 23 24 console.log(module); 25 // Module { 26 // id: '.', 27 // exports: {}, 28 // parent: null, 29 // filename: 'G:\\js-study\\第11節\\module\\01.js', 30 // loaded: false, 31 // children: [], 32 // paths: ['G:\\js-study\\第11節\\module\\node_modules', 33 // 'G:\\js-study\\第11節\\node_modules', 34 // 'G:\\js-study\\node_modules', 35 // 'G:\\node_modules' ] 36 // } 37 38 39 // 1.js定義如下 40 var a = 100; 41 module.exports.a = a; 42 43 // 2.js接收1.js 44 var m5 = require('./1') // 這個方法的返回值，其實就是被加載模塊中的module.exports 45 console.log(m5) // { a: 100} 46 47 /* 48 * 在模塊作用域中：還有一個內置的模塊對象: exports 49 * 它其實就是module.exports對象。 50 */ 51 52 console.log(exports === module.exports); // true 53 54 // 注意：使用exports或者module.exports時不要直接改變對象指向， 55 // 一旦改變對象指向exports和module.exports就不會相等。
Global全局變量之process對象
1 /* 2 * __filename: 返回當前模塊文件解析后的絕對路徑，該屬性其實並非全局的，而是模塊作用域下的。 3 * __dirname: 返回當前模塊文件所在目錄解析后的絕對路徑，該屬性也不是全局的，而是模塊作用域下的。 4 * 5 */ 6 7 8 /* 9 * process對象：它是一個全局對象，可以在任何地方都能訪問到它， 10 * 通過這個對象提供的屬性和方法，使我們可以對當前運行的程序的 11 * 進程進行訪問和控制 12 */ 13 14 // 1.process.argv: 一個包含命令行參數的數組，第一個元素是'node'， 15 // 第二個元素是.js文件的名稱。接下來的元素依次是命令行傳入的參數 16 17 // 在2.js中遍歷process.argv 18 process.argv.forEach(function (val, index, array) { 19 console.log(index + ': ' + val) 20 }) 21 22 // 執行 node 02.js one two three 命令, 23 // 打印： 24 // 0: node 25 // 1: ......../2.js 26 // 2: one 27 // 3: two 28 // 4: four 29 30 // 2.process.execPath: 返回啟動Node.js進程的可執行文件的絕對路徑名 31 console.log(process.execPath); // C:\Program Files\nodejs\node.exe 32 33 // 3.process.env: 返回用戶環境信息 34 console.log(process.env); 35 36 // 4.process.pid: 返回進程的pid(可到任務管理器中查看) 37 console.log(process.pid); // 4452 38 39 // 5.process.title: 當前進程的顯示名稱 40 console.log(process.title); // D:\WebStorm 2018.2.1\bin\runnerw.exe 41 42 // 6.process.arch: 返回當前CPU處理器架構arm/ia32/x64 43 console.log(process.arch); // x64
process對象：stdin, stdout標准輸入輸出流(IO)
1 /* 2 * process對象：stdin, stdout標准輸入輸出流(IO) 3 * stdin和stdout提供了操作輸入數據和輸出數據的方法， 4 * 我們通常稱為IO操作 5 * 6 * stdin: 標准輸入流 7 * stdout: 標准輸出流 8 */ 9 10 // 默認情況下，輸入流是關閉的，要監聽處理輸入流數據，首先要開啟輸入流 11 process.stdin.resume(); 12 13 // 用於監聽用戶的輸入數據 14 process.stdin.on('data', function (chunk) { 15 process.stdout.write(chunk) 16 console.log('用戶輸入了：' + chunk) 17 process.exit() 18 }) 19 20 /* 21 * 輸入a, b 輸出 a + b 的值 22 * */ 23 var a, 24 b; 25 26 process.stdin.resume(); 27 process.stdout.write('請輸入a的值：'); 28 process.stdin.on('data', function (chunk) { 29 if (!a) { 30 a = Number(chunk); 31 process.stdout.write('請輸入b的值：'); 32 } else { 33 b = Number(chunk); 34 process.stdout.write('a + b = ' + (a + b)); 35 process.exit(); 36 } 37 });
Global全局變量：Buffer類
一個用於更好的操作二進制數據的類，我們在操作文件或者網絡數據的時候
其實就是操作的二進制數據流，node為我們提供了一個更加方便的去操作這
種數據流的類Buffer,它是一個全局的類
console.log(global.Buffer === Buffer); // true
1.實例化Buffer類
1. new Buffer(size); size [Number] 創建一個Buffer對象，並為這個對象分配一個大小
最新版本已經變成Buffer.alloc(size),當我們為一個Buffer對象分配空間大小以后，其長度是
固定的，不能更改
1 var bf = new Buffer(5); 2 console.log(bf); // <Buffer 00 00 00 00 00> 3 var bf1 = Buffer.alloc(5); 4 console.log(bf1); // <Buffer 00 00 00 00 00>
2. new Buffer(array),最新版本已經改用Buffer.from(array).一旦初始化固定的數組長度之后，
其長度是固定的，不能更改
1 var bf = new Buffer([1, 2, 3]); 2 console.log(bf); // <Buffer 01 02 03> 3 4 var bf1 = Buffer.from([1, 2, 3]); 5 console.log(bf1); // <Buffer 01 02 03>
3. new Buffer(string, [encoding]),最新版本已經改用Buffer.from(string, [,encoding])
1 var bf = new Buffer('china', 'utf-8'); 2 console.log(bf); // <Buffer 63 68 69 6e 61> 3 4 var bf1 = Buffer.from('china', 'utf-8'); 5 console.log(bf1); // <Buffer 63 68 69 6e 61> 6 7 8 for (var i = 0; i < bf.length; i++) { 9 console.log(bf[i].toString(16)); // 63 68 69 6e 61 10 console.log(String.fromCharCode(bf[i]));// c h i n a 11 }
2.Buffer類的方法
1. buf.write(string, offset, length, encoding)
string: 要寫入的字符串
offset: 開始寫入的偏移量
length：要寫入的字節數
encoding: string的字符編碼，默認'utf-8'
1 var str = 'china'; 2 var buf = Buffer.alloc(5); 3 buf.write(str, 0, 2); 4 console.log(buf); // <Buffer 63 68 00 00 00>
2. buf.toString(encoding, start, end)
encoding: 使用字符的編碼，默認為'utf-8'
start: 開始解碼的字節偏移量
end: 結束解碼的字節偏移量，默認buf.length
1 var buf = Buffer.from('china'); 2 console.log(buf.toString('utf-8', 0, 2)); // ch
3. buf.toJSON() 返回buf的JSON格式
1 var buf = Buffer.from('china'); 2 console.log(buf.toJSON()); // { type: 'Buffer', data: [ 99, 104, 105, 110, 97 ] }
4. buf.slice(start, end)
start: 開始切片的偏移量。默認為0
end: 結束切片的偏移量，默認為buf.length
1 var buf = Buffer.from('china'); 2 var buf2 = buf.slice(0, 2); 3 console.log(buf2); // <Buffer 63 68> 4 // 注意：改變buf2時，buf也會發生變化
5.buf.copy()對buf進行拷貝
1 var buf = Buffer.from('china'); 2 var buf2 = Buffer.alloc(10); 3 buf.copy(buf2); 4 console.log(buf2); // <Buffer 63 68 69 6e 61 00 00 00 00 00> 5 // 注意：改變buf不會改變buf2
3.類方法，靜態方法
1 // 1.Buffer.isEncoding(encoding) 支持的編碼 2 3 console.log(Buffer.isEncoding('utf-8')); // true 4 console.log(Buffer.isEncoding('gbk')); // false 5 console.log(Buffer.isEncoding('hex')); // true 6 7 8 // 2.Buffer.isBuffer(obj) 判斷obj是否時Buffer對象 9 var arr = [1, 2, 3]; 10 var bf = new Buffer(10); 11 12 console.log(Buffer.isBuffer(arr)); // false 13 console.log(Buffer.isBuffer(bf)); // true 14 15 // 3.Buffer.byteLength(str) 獲取字符串的字節長度 16 17 var str1 = 'china'; 18 19 console.log(str1.length); // 5 20 console.log(Buffer.byteLength(str1)); // 5 21 22 var str2 = '中國'; 23 24 console.log(str2.length); // 2 25 console.log(Buffer.byteLength(str2, 'utf-8')); // 6 26 console.log(Buffer.byteLength(str2, 'ascii')); // 2 27 28 29 // 4.Buffer.contact(list, totalLength) 拼接兩個buffer 30 // list: buf數組 31 // totalLength: 合並后Buffer總長度 32 33 var str1 = 'china', 34 str2 = '中國'; 35 var list = [Buffer.from(str1), Buffer.from(str2)]; 36 console.log(list); // [ <Buffer 63 68 69 6e 61>, <Buffer e4 b8 ad e5 9b bd> ] 37 38 var bf = Buffer.concat(list, 15); 39 console.log(bf); // <Buffer 63 68 69 6e 61 e4 b8 ad e5 9b bd 00 00 00 00>
4.Buffer應用實例
1 process.stdout.write('請輸入:'); // 中國 2 3 process.stdin.resume(); 4 5 process.stdin.on('data', function (chunk) { 6 console.log(chunk); // <Buffer e5 bc a0 e5 9b bd 0a> 7 console.log(chunk.toString()); // 中國 8 });
FileSystem 文件系統
該模塊是核心模塊,需要使用require導入后使用
該模塊提供了操作文件的一些API
1. fs.open(path, flags, [mode], callback) 異步打開文件
1 /* 2 * fs.open(path, flags, [mode], callback) 異步打開文件 3 * 4 * path: 要打開的文件路勁 5 * flags: 打開文件的方式 讀/寫 6 * mode: 設置文件的模式 讀/寫/執行 7 * callback: 回調 8 * err: 文件打開失敗的錯誤保存在err里面,如果成功err為null 9 * fd: 被打開文件的標識 10 * */ 11 12 // 引入 fs 核心模塊 13 var fs = require('fs'); 14 15 // 1.打開一個存在的文件 16 17 fs.open('1.txt', 'r', function (err, fd) { 18 console.log(err); // null 19 console.log(fd); // 3 20 }); 21 22 // 2.打開一個不存在的文件 23 24 fs.open('2-new.txt', 'r', function (err, fd) { 25 console.log(err); // 返回錯誤對象 26 console.log(fd); // undefined 27 });
2. fs.openSync(path, flags, [mode]) 同步打開文件
1 /* 2 * fs.openSync(path, flags, [mode]) 同步打開文件 3 * 4 * path: 要打開的文件路勁 5 * flags: 打開文件的方式 讀/寫 6 * mode: 設置文件的模式 讀/寫/執行 7 * */ 8 9 // 引入 fs 核心模塊 10 var fs = require('fs'); 11 12 var fd = fs.openSync('1.txt', 'r'); 13 console.log(fd); // 3
3. fs.read(fd, buffer, offset, length, position, callback)
1 /* 2 * fs.read(fd, buffer, offset, length, position, callback) 3 * 4 * fd: 通過open方法成功打開一個文件返回的編號 5 * buffer: buffer對象 6 * offset: 偏移量(放到buffer的開始位置) 7 * length: 添加到buffer中的內容長度 8 * position: 當前文件里面的位置 9 * callback: 回調 10 * err: 11 * bytesRead: 返回buf的長度 12 * buffer: 返回的buf 13 * 14 * 15 * */ 16 17 // 引入 fs 核心模塊 18 var fs = require('fs'); 19 20 fs.open('1.txt', 'r', function (err, fd) { 21 if (err) { 22 console.log('文件打開失敗'); 23 } else { 24 25 // 讀取文件 26 var bf1 = new Buffer(10); 27 console.log(bf1); // <Buffer 00 00 00 00 00 00 00 00 00 00> 28 fs.read(fd, bf1, 0, 4, null, function (err, bytesRead, buffer) { 29 console.log(bf1); // <Buffer 61 62 63 64 00 00 00 00 00 00> 30 console.log(bytesRead); // 4 31 console.log(buffer); // <Buffer 61 62 63 64 00 00 00 00 00 00> 32 }) 33 } 34 });
4. fs.write(fd, buffer, offset, length, position, callback)
1 /* 2 * fs.write(fd, buffer, offset, length, position, callback) 3 * 4 * fd: 打開的文件 5 * buffer: 要寫入的數據 6 * offset: buffer對象中要寫入的數據的起始位置 7 * length: 要寫入的buffer數據的長度 8 * position: fd中的起始位置 9 * callback: 回調 10 * err: 錯誤提示 11 * bytesWritten: 寫入的字節數 12 * buffer: 返回寫入的buffer 13 * 14 * */ 15 16 17 // 引入 fs 核心模塊 18 var fs = require('fs'); 19 20 fs.open('1.txt', 'r+', function (err, fd) { 21 if (err) { 22 console.log('打開文件失敗') 23 } else { 24 var bf = Buffer.from('123'); 25 fs.write(fd, bf, 0, 2, 10, function (err, bytesWritten, buffer) { 26 console.log(err); // null 27 console.log(bytesWritten); // 2 28 console.log(buffer); // <Buffer 31 32 33> 29 }) 30 } 31 });
5. fs.close(fd, callback) 關閉fs
1 /* 2 * fs.close(fd, callback) 3 * 4 * fd: 打開的文件 5 * callback: 回調 6 * 7 * 注意: 打開文件操作完畢, 最后需要關閉文件 8 * */ 9 10 var fs = require('fs'); 11 12 fs.open('1.txt', 'r', function (err, fd) { 13 // TODO 14 fs.close(fd, function () { 15 16 }) 17 });
6. fs.writeFile(file, data, options, callback) 給文件寫入數據
1 /* 2 * fs.writeFile(file, data, options, callback) 給文件寫入數據 3 * 4 * file: [string] | [Buffer] | [URL] | [integer]文件名或文件描述符 5 * data: [string] | [Buffer] | [TypedArray] | [DataView]寫入數據 6 * options: 7 * encoding: 默認'utf-8' 8 * mode: 默認0o666 9 * flag: 默認w 10 * callback: 11 * err: 錯誤提示 12 * 13 * 注意: 如果文件不存在,即新建寫入 14 * 15 * */ 16 17 18 var fs = require('fs'); 19 20 fs.writeFile('2-new.txt', 'china', function (err) { 21 console.log(err); // null 22 });
7. fs.appendFile(path, data, option, callback)
1 /* 2 * fs.appendFile(path, data, option, callback) 3 * 4 * path: 文件名或文件描述符 5 * data: 添加數據 6 * option: 7 * encoding: 8 * mode: 9 * flag: 10 * callback: 11 * err: 12 * 13 * 注意: 文件不存在,即創建 14 * */ 15 16 var fs = require('fs'); 17 18 fs.appendFile('2-new.txt', '-very-good', function (err) { 19 console.log(err); // null 20 });
8. fs.exists(path, callback) 檢測文件是否存在
1 /* 2 * fs.exists(path, callback) 檢測文件是否存在 3 * 4 * path: 文件路徑 5 * callback: 6 * exists: [boolean] 7 * 8 * */ 9 10 var fs = require('fs'); 11 var filename = '3.txt'; 12 13 // 異步模式 14 fs.exists(filename, function (exists) { 15 console.log(exists); // false 16 17 if (!exists) { // 不存在 18 fs.writeFile(filename, 'china', function (err) { 19 if (err) { 20 console.log('出錯了'); 21 } else { 22 console.log('創建新文件成功'); 23 } 24 }) 25 } else { // 存在 26 fs.appendFile(filename, '-good', function (err) { 27 if (err) { 28 console.log('新的內容追加失敗'); 29 } else { 30 console.log('新內容追加成功'); 31 } 32 }) 33 } 34 35 36 }); 37 38 // 同步模式 39 if (!fs.existsSync(filename)) { 40 fs.writeFileSync(filename, 'china'); 41 console.log('新文件創建成功'); 42 } else { 43 fs.appendFileSync(filename, '-good'); 44 console.log('追加內容成功'); 45 }
9. fs.readFile(filename, options, callback) 異步讀取一個文件的全部內容
1 /* 2 * fs.readFile(filename, options, callback) 異步讀取一個文件的全部內容 3 * 4 * callback: 5 * err: 6 * data: 數據 7 * 8 * */ 9 10 var fs = require('fs'); 11 12 fs.readFile('3.txt', function (err, data) { 13 if (err) { 14 console.log('文件讀取錯誤'); 15 } else { 16 console.log(data.toString()); // china-good 17 } 18 })
10. fs.unlink(path, callback) 刪除指定文件
1 /* 2 * fs.unlink(path, callback) 刪除指定文件 3 * 4 * callback: 5 * err 6 * */ 7 8 var fs = require('fs'); 9 10 fs.unlink('3.txt', function (err) { 11 if (err) { 12 console.log('刪除失敗'); 13 } else { 14 console.log('刪除成功'); 15 } 16 })
11. fs.rename(oldPath, newPath, callback) 重命名
1 /* 2 * fs.rename(oldPath, newPath, callback) 重命名 3 * oldPath: 老名字 4 * newPath: 新名字 5 * callback: 6 * err: 7 * */ 8 9 var fs = require('fs'); 10 11 fs.rename('2-new.txt', '2-new.txt', function (err) { 12 if (err) { 13 console.log('重命名失敗'); 14 } else { 15 console.log('重命名成功'); 16 } 17 });
12. fs.stat(filename, callback) 獲取文件信息
1 /* 2 * fs.stat(filename, callback) 獲取文件信息 3 * 4 * filename: 文件 5 * callback: 回調 6 * 7 * */ 8 9 var fs = require('fs'); 10 11 fs.stat('2-new.txt', function () { 12 console.log(arguments); 13 });
13. fs.watch(filename, option, listener) 監聽文件
1 /* 2 * fs.watch(filename, option, listener) 監聽文件 3 * 4 * listener: 回調函數 5 * eventType: 事件 6 * filename: 文件 7 * 8 * */ 9 10 var fs = require('fs'); 11 12 var filename = '2-new.txt'; 13 14 fs.watch(filename, function (ev, fn) { 15 console.log(ev); 16 17 if (fn) { 18 console.log(fn + '發生了改變'); 19 } else { 20 console.log('....'); 21 } 22 })
14. 文件夾操作
1 /* 2 * fs.mkdir(path, [mode], callback) 創建文件夾 3 * */ 4 5 var fs = require('fs'); 6 7 fs.mkdir('./1', function () { 8 console.log(arguments); 9 }); 10 11 12 /* 13 * fs.rmdir(path, [mode], callback) 刪除文件夾 14 * 15 * */ 16 /* 17 fs.rmdir('./1', function () { 18 console.log(arguments); 19 }); 20 */ 21 22 /* 23 * fs.readdir(filename, callback) 讀取文件夾 24 * */ 25 fs.readdir('../第11節', function (err, fileList) { 26 fileList.forEach(function (f) { 27 fs.stat(f, function (err, info) { 28 switch (info.mode) { 29 case 16822: 30 console.log('[文件夾]' + f); 31 break; 32 33 case 33206: 34 console.log('[文件]' + f); 35 break; 36 37 default: 38 console.log('[其它類型]' + f); 39 break; 40 } 41 }) 42 }) 43 44 45 })
15. 前端項目自動化創建
1 /* 2 * 前端項目自動化創建 3 * */ 4 5 var projectData = { 6 name: 'project', 7 fileData: [ 8 { 9 name: 'css', 10 type: 'dir' 11 }, 12 { 13 name: 'js', 14 type: 'dir' 15 }, 16 { 17 name: 'images', 18 type: 'dir' 19 }, 20 { 21 name: 'index.html', 22 type: 'file', 23 content: '<html>\n\t<head>\n\t\t<title>title</title>\n\t</head>\n\t<body>\n\t\t<div>Hello Node</div>\n\t</body>\n</html>' 24 }, 25 ] 26 }; 27 28 var fs = require('fs'); 29 30 if (projectData.name) { 31 fs.mkdirSync(projectData.name); 32 var fileData = projectData.fileData; 33 34 if (fileData && fileData.forEach) { 35 fileData.forEach(function (f) { 36 37 f.path = projectData.name + '/' + f.name; 38 39 switch (f.type) { 40 case 'dir': 41 fs.mkdirSync(f.path); 42 break; 43 case 'file': 44 fs.writeFileSync(f.path, f.content) 45 break; 46 } 47 48 }) 49 } 50 51 52 }
16. 自動合並文件
1 /* 2 * 自動合並 3 * */ 4 var fs = require('fs'); 5 6 var fileDir = './project/source'; 7 8 fs.watch(fileDir, function (ev, file) { 9 /* 10 * 這里不需要判斷file是否有內容 11 * 只要有一個文件發生了變化,我們就需要對這個文件夾 12 * 下得所有文件進行讀取,然后合並 13 * */ 14 fs.readdir(fileDir, function (err, dataList) { 15 16 var arr = []; 17 18 dataList.forEach(function (f) { 19 20 var info = fs.statSync(fileDir + '/' + f); 21 22 if (info.mode === 33206) { 23 arr.push(fileDir + '/' + f); 24 } 25 26 }); 27 28 // 讀取數組中得文件內容,並合並 29 30 var content = ''; 31 arr.forEach(function (f) { 32 var c = fs.readFileSync(f); 33 content += c.toString() + '\n'; 34 }) 35 36 console.log(content); 37 38 fs.writeFileSync('./project/js/index.js', content); 39 40 }); 41 42 });
Http
1.用戶通過瀏覽器發送一個http的請求到指定的主機
2.服務器接收到該請求，對該請求進行分析和處理
3.服務器處理完成以后，返回對應的數據到用戶機器
4.瀏覽器接收服務器返回的數據，並根據接收到的進行分析和處理
客戶端 服務端
由客戶端發送一個http請求到指定的服務端
->
服務端接收並處理請求
->
返回數據到客戶端
1 /* 2 * 搭建一個http的服務器，用於處理用戶發送的http請求 3 * 需要使用node提供的一個模塊 http 4 */ 5 6 // 引入 http 核心模塊 7 var http = require('http'); 8 9 // 通過http模塊下的createServer創建並返回一個web服務器對象 10 var server = http.createServer(); 11 12 // 監聽服務器錯誤 13 server.on('error', function (err) { 14 console.log('錯誤：', err); 15 }); 16 17 // 監聽 18 server.on('listening', function () { 19 console.log('listening.....') 20 }); 21 22 // 獲取請求 23 server.on('request', function (req, res) { 24 console.log('有客戶端請求了，url地址：', req.url); 25 26 // 自定義添加響應給客戶端的頭部信息 27 res.setHeader('name', 'winner'); 28 29 // 響應給客戶端的頭部信息(只能在res.setHeader()之后和res.end()之前調用) 30 res.writeHead(200, 'ok', { 31 'content-type': 'text/html;charset=utf-8', // 告訴客戶端返回信息的形式 32 }); 33 34 // 響應發送給客戶端的內容 35 res.write('<h1>Hello World</h1>'); 36 // 響應發送給客戶端 37 res.end(); 38 39 }); 40 41 // 監聽端口號 42 server.listen(3000);
url處理
1 /* 2 * url的處理 3 * */ 4 5 // 引入 http 核心模塊 6 var http = require('http'); 7 // 引入 url 核心模塊 8 var url = require('url'); 9 10 11 // 通過http模塊下的createServer創建並返回一個web服務器對象 12 var server = http.createServer(); 13 14 // 監聽服務器錯誤 15 server.on('error', function (err) { 16 console.log('錯誤：', err); 17 }); 18 19 // 監聽 20 server.on('listening', function () { 21 console.log('listening.....') 22 }); 23 24 // 獲取請求 25 server.on('request', function (req, res) { 26 // req.url: 訪問路徑 27 // ？后面的部分 query string 28 var urlStr = url.parse(req.url); 29 // console.log(urlStr); 30 31 switch (urlStr.pathname) { 32 case '/': 33 // 首頁 34 res.writeHead(200, { 35 'content-type': 'text/html;charset=utf-8' 36 }); 37 res.end('<h1>這是首頁</h1>'); 38 break; 39 case '/user': 40 //用戶首頁 41 res.writeHead(200, { 42 'content-type': 'text/html;charset=utf-8' 43 }); 44 res.end('<h1>這是個人中心</h1>'); 45 break; 46 default: 47 // 處理其它情況 48 res.writeHead(404, { 49 'content-type': 'text/html;charset=utf-8' 50 }); 51 res.end('<h1>頁面被LEO吃掉了</h1>'); 52 break; 53 } 54 55 }); 56 57 // 監聽端口號 58 server.listen(3000);
get和post請求
1 /* 2 * 使用fs模塊實現行為表現分離 3 * */ 4 5 // 引入 http 核心模塊 6 var http = require('http'); 7 8 // 引入 url 核心模塊 9 var url = require('url'); 10 11 // 引入 fs 核心模塊 12 var fs = require('fs'); 13 14 // 引入 querystring 核心模塊 15 var qs = require('querystring'); 16 17 // 引入 __dirname 功能 18 var HtmlDir = __dirname + '/html/' 19 20 // 通過http模塊下的createServer創建並返回一個web服務器對象 21 var server = http.createServer(); 22 23 // 監聽服務器錯誤 24 server.on('error', function (err) { 25 console.log('錯誤：', err); 26 }); 27 28 // 監聽 29 server.on('listening', function () { 30 console.log('listening.....') 31 }); 32 33 // 獲取請求 34 server.on('request', function (req, res) { 35 // req.url: 訪問路徑 36 // ？后面的部分 query string 37 var urlStr = url.parse(req.url); 38 console.log('有客戶端訪問了！'); 39 40 41 switch (urlStr.pathname) { 42 case '/': 43 // 首頁 44 sendData(HtmlDir + 'index.html', req, res); 45 break; 46 case '/user': 47 //用戶首頁 48 sendData(HtmlDir + 'user.html', req, res); 49 break; 50 case '/login': 51 //用戶首頁 52 sendData(HtmlDir + 'login.html', req, res); 53 break; 54 case '/login/check': 55 //登錄請求 56 if (req.method.toUpperCase() === 'POST') { 57 58 var str = ''; 59 60 req.on('data', function (chunk) { 61 str += chunk; 62 }); 63 64 req.on('end', function () { 65 console.log(qs.parse(str)); 66 }); 67 res.writeHead(200, { 68 'content-type': 'text/html;charset=utf-8' 69 }); 70 res.end('歡迎'); 71 } else { 72 console.log(qs.parse(urlStr.query)); // get請求 73 } 74 75 76 break; 77 default: 78 // 處理其它情況 79 sendData(HtmlDir + 'other.html', req, res); 80 break; 81 } 82 83 }); 84 85 function sendData(file, req, res) { 86 fs.readFile(file, function (err, data) { 87 if (err) { 88 res.writeHead(404, { 89 'content-type': 'text/html;charset=utf-8' 90 }); 91 res.end('<h1>頁面被LEO吃掉了</h1>'); 92 } else { 93 res.writeHead(200, { 94 'content-type': 'text/html;charset=utf-8' 95 }); 96 res.end(data); 97 } 98 }) 99 } 100 101 // 監聽端口號 102 server.listen(3000);