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
odejs
ode.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.1in
unnerw.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>
	<head>
		<title>title</title>
	</head>
	<body>
		<div>Hello Node</div>
	</body>
</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() + '
';
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);

相关阅读:
【codeforces 766C】Mahmoud and a Message
【codeforces 766D】Mahmoud and a Dictionary
【b704 && BZOJ 1999】树网的核
 优秀Java程序员必须了解的GC工作原理
 Apparatus, system, and method for automatically minimizing real-time task latency and maximizing non-real time task throughput
NODEJS网站
 day63-webservice 01.cxf介绍
 04.webservice客户端调用
 03.WSDL分析
 02.socket实现远程调用
原文地址：https://www.cnblogs.com/wanghao123/p/10536043.html