NodeJs入门基本教程
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);
版权声明：本文为wanghao123原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。