Node.

1.简介Node.js

不能单纯的使用js做后端开发 需要通过node.js

在使用js 做后端开发的时候需要借用Node.js

1.1 Node .js中包含的js运行环境

Node.js使一个基于chrome V8引擎的JavaScript

总结：浏览器是js的前端运行环境 Node.js 是js的后端的运行环境

Node.js包含了以下两个核心的内容

1. cream V8的引擎
2. Node.js的内置的API（API 是接口是通道 是用来负责一个软件和另外一个软件的沟通与交流的）
3. Node.js中不能使用DOM和BOM操作的

1.2Node.js 作用

Node.js 是底层 基于Node.js的底层可以在此基础上做很多事情

1.3 Node.js 学习路线

1. JavaScript 的基础语法
2. Node.js内置API模块
3. 第三方API模块 mysql 等

1.4 终端

终端是为程序员设计的人机交互的一种方式

• 终端的使用
  打开终端， node 后面接 文件名
• 终端中的快捷键

  上箭头 ：定位到上一次执行的命令

  Tap：自动补全

  Esc：清空当前输入的命令

  输入cls：清空终端的所用的命令

1.5 Buffer(缓冲器)

buffer 是一个和数组类似的

2.文件系统模块

fs 是Node.js 官方提供的 用来对文件进行读写

2.1 导入 fs

通过这行命令来导入fs模块

require 需求 需要做(某事)

1

const fs=require('fs');

2.2 文件的读取与写入

fs.readFile() 读取文件内容

fs.readFile(path,[options]，callback)

path 路径 options 选择 callback 回收

参数1：读取文件的路径

参数2：读取文件的时候采用的编码格式

参数3：回调函数function（err ，dataStr）err失败的信息 dataStr 成功的信息

1
2
3
4
5
6
7
8

const fs=require('fs');
fs.readFile('1.txt','utf-8',function(err,dataStr){
if(err){
console.log('cg');
}else{
console.log(err);
}
})

fs.writeFile(path ,要写入的内容，callback)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

const fs=require('fs');
fs.readFile('./1.txt','utf-8',function(err,dataStr){
if(err){
return console.log('读取失败'+err.message);
}else{

const oldarr=dataStr.split(' ');//按照空格来进行分割
const newarr=[];
oldarr.forEach(item=>{
newarr.push(item.replace(':','='))
})
console.log(newarr);
const arr=newarr.join('\r\n');

}
fs.writeFile('./2.txt', arr,function(err,dataStr){
if(err){
console.log('写入失败');
}else{

return console.log(dataStr);
}
}  )
}  )

调用fs模块来写入文件

1
2
3
4
5
6
7
8

cosnt fs=require('fs')；
fs.writeFile('/.index.html','写入的内容',function(err){
if(err){
console.log('写入失败');
}else{
console.log('写入成功');
}
})

flag 标记

r read :只读

w write :只写

a append :追加

如果要想文件的后面的内容可以追加 只需要将文件的flag设置为a

1
2
3
4
5
6
7
8

const fs=require('fs')；
fs.writeFIle('/1.html','哈哈哈哈哈',{flag:'a'},function(err){
if(err){
console.log('sb');
}else{
console.log('cg');
}
} )

2.3 异步写入文件

**同步就是等结果返回后再执行 **

异步就是不等返回结果就开始执行

判断是同步还是异步执行就在回调函数中和 外部输出 查看返回结果

fs.writeFileSync(‘路径’,’内容)

1

fs.writeFileSync('./1,txt','ddddddd');

2.4路径动态拼接、

如果是以相对路径来看就很容易出现路径错误

解决方法：直接提供完整的文件提供路径来执行 同时在js中/表示的是转义的意思我们需要手动的去 加一个/ 来解决

1
2
3
4
5
6
7
8
9

const fs=require('fs');
fs.readFile('C:/Users/WYQ/Desktop/Node/1.txt','utf8',function(err,dataStr){
if(err){
return console.log('cw');

}else{
return console.log(dataStr);
}
} )

但是提供完整的存放路径可以解决路径拼接的问题 但是移植性很差

–dirname 表示当前文件所处的位置

• –dirname

  使用dirname 拼接当前文件的名称的方式就能解决 移植性差的问题

  1 2 3 4 5 6 7 8 9 10

  const fs=require('fs'); console.log(__dirname); fs.readFile(__dirname+'/1.txt','utf8',function(err,dataStr){ if(err){ return console.log('cw'); }else{ return console.log(dataStr); } } )

2.5 文件的写入场景

当我们需要持久化保存数据的时候我们就需要文件写入

1. **文件的下载 **
2. 文件的安装
3. 日志 （聊天记录）
4. 数据库
5. 网盘

2.6 文件写入流

引入fs模块 创建写入流对象

1
2
3
4
5
6
7
8

const fs=require('fs');
//创建写入流对象
const ws=fs.createwriteStream('./3.txt');

 //向文件中写入内容
 ws.write('我是写入的内容');
 //关闭写入流
 ws.clear();

对于简单的写入较少的情况想使用writeFile

对于多次 写入较多文件的情况下使用CreteWriteStream

2.7 文件的读取

fs.readFile(‘path’,回调函数（err(错误对象),data(读取成功后的文件内容)）)

//同步读取
fs.readFileSync(‘文件路径’);

1
2
3
4
5
6
7
8
9
10
11
12
13
14

const fs=require('fs');
// fs.readFile('path',回调函数（err(错误对象),data(读取成功后的文件内容)）)
fs.readFile('./1.txt',function(err,data){
	if(err){
		console.log('读取失败'+err);
	}else{
		return console.log(data.toString());
	}
} )


//同步读取
let data=fs.readFileSync('./1.txt');
console.log(data.toString());

2.8 读取文件流

1
2
3
4
5
6
7
8
9
10

const fs=require('fs');

//创建读取流对象
let fsread=fs.createReadStream('./1.txt');


//绑定事件   on 有when的时候 当，，，的时候
fsread.on('data',(chuck)=>{
	console.log(chuck);
})

2.9 文件的复制

1
2
3
4
5
6
7
8
9
10
11

const fs=require('fs');

// 创建流对象
const ws=fs.createWriteStream('./1.txt');
const rs=fs.createReadStream('./4.txt');


//绑定事件读取内容
rs.on('data',function(chunk){
	ws.wirte(chunk);
} );

通过node.js 自带的copy方法也能实现文件的复制

1
2

const fs=require('fs');
fs.copy('复制的文件','目标地址',回调函数)；

2.10 文件的重命名

1. 引入fs模块
2. 调用rename（）方法
   raname(‘目标文件’,‘新的文件’，回调函数)。

1
2
3
4
5

const fs=require('fs');
fs.rename('./1.txt','./2222222.txt',function(err){
	if(err) throw err;
	console.log('重命名成功');
} )

2.11 删除文件

1
2
3
4

fs.unlink('路径'，回调（err）{
	if（err）throw;
	console('cg')
})

2.12 文件夹操作

1. 创建 文件夹
2. 删除文件夹
3. 读取文件夹

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

const fs=require('fs');
// fs.mkdir('路径',回调函数（err）{});


fs.mkdir('new',function(err){
	if(err) throw err;
	console.log('cg');
})

fs.readdir('./new',function(err,files){
	if(err) throw err;
	//读取文件下下的列表
	console.log(files);
} )

fs.rmdir('./new',err=>{
	if(err) throw err;
	console.log(cg);
})

2.13 获取文件的状态

不能通过文件的名称来判断文件的类型

**stats 接收的回调是一个对象 **

1
2
3
4
5

const fs=require('fs');
fs.stat('路径'，function(err,stats){
	if(err) throw err;

})

文件创建练习

像这种 异步的任务下面有回调函数 然后还有 回调 就称为回调地狱

1
2
3
4
5
6
7
8
9

const fs=require('fs');
//创建文件夹
fs.mkdir('D:/dome',err=>{
	if(err) throw err;
	fs.mkdir('D:dome/image/logo.png','abc',err=>{
	 	if(err) throw err;
	 	console.log('文件创建成功');
	})
})

3.path 路径模块

path 是Node.js官方用来处理路径的模块 满足用户对路径处理的需求

3.1 path 导入

1

const path=require('path');

3.2 路径拼接 join

join 方法可以把多个路径片段拼接成一个完整的路径片段

注意：../ 这个会抵消掉前面的一层路径

1
2
3

const path=require('path');
let patharr=path.join('/a','/b/c','../','/d');
console.log(patharr)

上面代码输出为：\a\b\d

在后面如果要使用路径拼接的时候就只用path方法

1
2
3
4
5
6
7
8
9
10
11

const path=require('path');
const fs=require('fs');
console.log(__dirname);
fs.readFile(path.join(__dirname,'/1.txt'),'utf8',function(err,dataStr){
	if(err){
		return console.log('cw');

	}else{
		return console.log(dataStr);
	}
} )

3.3 获取路径的最后部分 basename

使用path.basename()方法可以获取路径中的最后一部分 通常用啦获取文件中的文件名

**path.basename(文件路径path,文件的后缀名) **

**第二个 参数是是否去掉文件的后缀名 **

const path=require('path');
const fpath='a/b/b/index.html';
//获取完整的文件名 包括后缀
let fname=path.basename(fpath);
console.log(fname);
//返回值   index.html

//清楚掉后缀
let fname2=path.basename(fpath,'.html');
console.log(fname2);
//返回值    index

3,4 获取文件的扩展名 extname()

path.extname( 文件路径 )

返回值是文件的后缀名

1
2
3

let fname3=path.extname(fpath);
console.log(fname3);
//返回值是 .html

4.缓冲器

buffer 是一个和数组类似的对象 但是是专门用来保存二进制的

• buffer 的初始化

  1 2 3

  const buf1=Buffer.alloc(10);创建一个10字节的buffer const buf2=Buffer.clocUnsafe(10); const bur3=Buffer.from('字符串'); 返回的是与字符对应的ascll

• Buffer 数据的读取

  1 2	const buf3=buffer.from('ddd'); console.log(buf3[0]);

• 设置

  1	buf[1]=00;//直接修改

• buffer 溢出

  **8 个2进制位能保存的最大的是255 如果这个数字超过255的话 **

  高于8位的二进制位就会被舍弃

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

#### 介绍

Buffer 是一个和数组类似的对象，不同是 Buffer 是专门用来保存二进制数据的

#### 特点

* 大小固定：在创建时就确定了，且无法调整
* 性能较好：直接对计算机的内存进行操作
* 每个元素大小为 1 字节（byte）

#### 操作

##### 创建 Buffer

* 直接创建 Buffer.alloc
* 不安全创建 Buffer.allocUnsafe

* 通过数组和字符串创建 Buffer.from

##### Buffer 读取和写入

可以直接通过 `[]` 的方式对数据进行处理，可以使用 toString 方法将 Buffer 输出为字符串

* ==[ ]== 对 buffer 进行读取和设置
* ==toString== 将 Buffer 转化为字符串

##### 关于溢出

溢出的高位数据会舍弃

##### 关于中文

一个 UTF-8 的中文字符大多数情况都是占 3 个字节

##### 关于单位换算

1Bit 对应的是 1 个二进制位

8 Bit = 1 字节（Byte）

1024Byte = 1KB 

1024KB = 1MB

1024MB = 1GB

1024GB = 1TB

平时所说的网速 10M 20M 100M 这里指的是 Bit ，所以理论下载速度 除以 8 才是正常的理解的下载速度

### 文件系统 fs

fs 全称为 file system，是 NodeJS 中的内置模块，可以对计算机中的文件进行增删改查等操作。

##### 文件写入

* 简单写入
  * fs.writeFile(file, data, [,options], callback);
  * fs.writeFileSync(file, data);
  * options 选项
    * `encoding` **默认值:** `'utf8'`
    * `mode`**默认值:** `0o666`
    * `flag` **默认值:** `'w'`
* 流式写入
  * fs.createWriteStream(path[, options])
    * path
    * options
      * ==flags==   **默认值:** `'w'`
      * `encoding `**默认值:** `'utf8'`
      * `mode`   **默认值:** `0o666`
    * 事件监听 open  close  eg:  ws.on('open', function(){});

##### 文件读取

* 简单读取
  * fs.readFile(file, function(err, data){})
  * fs.readFileSync(file)
* 流式读取
  * fs.createReadStream();

##### 文件删除

* fs.unlink('./test.log', function(err){});
* fs.unlinkSync('./move.txt');

##### 移动文件 + 重命名

* fs.rename('./1.log', '2.log', function(err){})
* fs.renameSync('1.log','2.log')

##### 文件夹操作

* mkdir  创建文件夹
  * path
  * options 
    * recursive 是否递归调用
    * mode  权限 默认为 0o777
  * callback 
* rmdir 删除文件夹
* readdir  读取文件夹

5.http协议

**超文本传输协议 都遵守这种约定来进行数据的传输 **

5.1 网页的加载过程

四次 浏览器向服务器发送请求 服务器向浏览器返回响应

5.2 请求报文

请求报文由四个部分组成

1. 请求行

   三段内容组成：

   • 请求方式 ：常见的就是get 个psot 其他的用的相对较少
   • **URL： **

   ** 组成：**

   协议 ：****https 、 http mongodb ftp ssh 协议

   **域名 ： **www.badu.com 域名IP地址

   路径 ： /s

   查询字符串：rsv_spt=1 & rsv_iqid=0xd1044 表示的是映射的关系 参数

   • HTTP/1.1 HTTP协议的版本 这个一般是固定的

2. 请求头 格式：请求头的名字：请求头的值

   1 2 3 4 5 6 7 8 9 10

   请求行 GET https://www.baidu.com /?tn=80035161_1_dg HTTP/1.1 请求头 Accept: text/html, application/xhtml+xml, image/jxr, */* 表明客户端所能接受的数据的类型 Accept-Language: zh-Hans-CN,zh-Hans;q=0.5 表明客户端支持的语言类型 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; Touch; rv:11.0) like Gecko 客户端的字符串标志 Accept-Encoding: gzip, deflate 表明客户端支持的压缩方式 Host: www.baidu.com 服务端的主机名 Connection: Keep-Alive 连接配置 Keep-Alive 保持连接 close 断开 Cookie: BD_UPN=1126314751; BD_HOME=1; Cookie 小甜饼 Cache-Control: max-age=120 缓存控制 Upgrade-Insecure-Requests: 1 强制浏览器发送请求时使用 https

3. 请求空行 在格式上做一些分割

4. 请求体

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   请求体 POST https://processon.com/login HTTP/1.1 Accept: text/html, application/xhtml+xml, image/jxr, */* Referer: https://processon.com/login?f=index Accept-Language: zh-Hans-CN,zh-Hans;q=0.5 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; Touch; rv:11.0) like Gecko Content-Type: application/x-www-form-urlencoded Accept-Encoding: gzip, deflate Host: processon.com Content-Length: 61 Connection: Keep-Alive Cache-Control: no-cache login_email=779498590@qq.com&login_password=GREM9pus.fek-soos

   请求体内容

   1	login_email=779498590@qq.com&login_password=GREM9pus.fek-soos

   form 表单

   1 2 3 4 5

   <form method="post"> <input name="login_email"> <input name="login_password"> <input type="submit" value="登录"/> </form>

   请求体的格式是非常灵活的, 不

   1

5.3 响应报文

1. 组成部分

   • 响应行

     协议的版本 HTTP/1.1

     响应的状态码

     • 200 成功
     • 302 跳转
     • 404 找不到资源
     • 403 禁止的
     • 500 服务器内部错误

       1 2 3 4 5

       信息响应(100–199)， 成功响应(200–299)， 重定向(300–399)， 客户端错误(400–499) 服务器错误 (500–599)响应的状态字符串

     **响应的状态字符串 **

   • 响应头

     响应头格式与请求头格式一致 『名字: 值』

     1 2 3 4 5 6 7 8 9 10 11 12 13

     Bdpagetype: 1 Bdqid: 0xf4330ae2000009bd Cache-Control: private Connection: keep-alive Content-Type: text/html;charset=utf-8 Date: Sat, 07 Nov 2020 03:08:03 GMT Expires: Sat, 07 Nov 2020 03:08:03 GMT Server: BWS/1.1 Set-Cookie: BDSVRTM=12; path=/ Strict-Transport-Security: max-age=172800 Traceid: 1604718483242292455417596420134845548989 X-Ua-Compatible: IE=Edge,chrome=1 Content-Length: 289603

     Bdpagetype 和 Bdqid 为百度自定义的响应头

     • Cache-Control 缓存控制 private 只允许客户端缓存数据 public
     • Connection 连接设置
     • Content-Type 『响应体』内容的类型
     • https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Basics_of_HTTP/MIME_types
     • text/html 表明响应体为 HTML 内容
     • text/css 表明响应体为 CSS 内容
     • application/javascript 表明响应体为 JavaScript
     • image/png 表明响应体为 png 的图片
     • Date 响应时间
     • Expires 过期时间
     • Server 服务器信息
     • Set-Cookie 设置 cookie
     • Strict-Transport-Security 响应头与Upgrade-Insecure-Requests结合使用
     • Traceid 跟踪 id
     • X-Ua-Compatible IE=Edge,chrome=1 强制IE浏览器使用最新的解析器解析网页, 使用 chrome 的内核解析网页
     • Content-Length 响应体的长度

   • 响应空行

   • 响应体

     响应体格式比较灵活, 场景的格式有

     • HTML
     • JavaScript
     • CSS
     • JSON
     • **图片 **

5.4Cream 查看请求报文与响应报文( 重要 )

5.5 创建HTTP服务

1. 引入模块
2. 调用方法 创建服务对象
3. 监听端口 启动服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//1. 引入 http 模块
const http = require('http');
//2. 调用方法 创建服务对象
/**
 * request 请求报文的封装对象
 * response 响应报文的封装对象
 */
const server = http.createServer(function(request, response){
    response.end('hello http selver');
});

//3. 监听端口 启动服务
server.listen(80, function(){
    console.log('服务已经启动, 端口 80 监听中.....');
});  

5.6 请求报文的请求方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

//1. 引入 http 模块
const http = require('http');
const URL=require('url');
//引入URL 的模块
//2. 调用方法 创建服务对象
/**
 * request 请求报文的封装对象
 * response 响应报文的封装对象
 */
const server = http.createServer(function(request, response){
   // 获取请求报文中的内容
   // 1.请求的类型  GIT
   // console.log(request.method);




   // 2.请求的url
   // console.log(request.url);
   //请求的http 协议版本
   // console.log(request.httpVersion);

   // 客户端会向服务端发送请求 发送的是请求报文 请求报文
    //请求报文由请求行 请求行包括 get post 、url  由协议域名 端口组成

    //服务端会向客户端发送响应 这个叫做响应报文


   //------------------------------获取URL中的路径的部分


   console.log(URL.parse(request.url,true));


   //------------------------------请求头信息
   console.log(request.headers);
   response.end('home');

   //修改js代码一定要重启node服务 

});

//3. 监听端口 启动服务
server.listen(80, function(){
    console.log('服务已经启动, 端口 80 监听中.....');
});

5.7响应报文的一些api

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

const http=require('http');

const server=http.createServer(function(request,respose){
	//响应行
	//状态码 
	 respose.statusCode=404;
	 
	 //状态字符串
	 respose.statusMessage='dadfasdf';
	 
	 
	 
	 //响应头
	 respose.setHeader('Content-type','text/html;charset=utf-8');
	 //自定义信息
	 respose.setHeader('abc','1000000');
	 
	 //响应体 响应体不能为空
	 respose.write('dasfasddfasdfffffffffffffffffffffffffffffffffffff');
	respose.end('hello node js server');
} )
 server.listen(80,function(){
	 console.log('dddddddd');
 } )

5.8 Http 练习（多个）

• 背景变色

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

  const http = require('http'); const url = require("url"); const server = http.createServer((request, response) => { //设置响应头 // response.setHeader('Content-Type','text/html;charset=utf-8'); // 获取请求 url 中的 『bg』参数 let bg = url.parse(request.url, true).query.bg ? url.parse(request.url, true).query.bg : '#edf' //设置响应体 response.end(` <!doctype html> <html> <head> <meta charset="utf-8"> <style> body{ background: ${bg}; } </style> </head> <body> <h1> 身是菩提树，心如明镜台，时时勤拂拭，勿使惹尘埃。 </h1> </body> </html> `); }); server.listen(80);

• 数据表格加载、

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

  const data=[ {id:1, name:'hahah', song:'dfjasdf'}, { id:2, name:'dfsadsf', song:'dadfewfghh' } ]; const http=require('http'); const fs=require('fs'); const server=http.createServer(function(request, response){ let str=''; for(let i=0;i<data.length;i++){ str+=`<tr><td>${data[i].id}</td><td>${data[i].name}</td><td>${data[i].song}</td></tr>`; } response.end(` <html> <head> <meta charset="utf-8" /> <title></title> </head> <body> <table> <tr><td>id</td><td>name</td><td>song</td></tr> ${str} </table> <script src='127.0.0.1/'></script> </body> </html> `); } ); server.listen(80,function(){ console.log('80 '); } )

• 不同请求返回不同结果

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

  //根据不同的路径来返回不同的结果 const http=require('http'); const url=require('url'); const server=http.createServer(function(reqeust,respons){ //获取请求类型 gat let method=request.method; //获取路径 let pathname=url.parse(reqeust.url,true).pathname; //判断 看是什么请求 if(mathod.toUpperCase()==='GET'&&pathname==='/login'){ respons.write('登录'); } if(mathod.toUpperCase()==='GET'&&pathname==='/register'){ respons.write('注册'); }else{ respons.end('<h1>404 not found<h1>'); } } ); server.listen(80,function(){ console.log('cg'); } )

• 响应js代码

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

  const data=[ {id:1, name:'hahah', song:'dfjasdf'}, { id:2, name:'dfsadsf', song:'dadfewfghh' } ]; const http=require('http'); const fs=require('fs'); const url=require('url'); const server=http.createServer(function(request, response){ //---------存在中文解码错误的问题 所以需要我们调用一个一个函数来对中文路径来进行解码 //decodeURL 能对中文路径进行解码 let pathname=decodeURI(url.parse(request.url,true).pathname); //如果请求为路径为 变色.js的话就返回解析后的js if(pathname==='/dome'){ let str=''; for(let i=0;i<data.length;i++){ str+=`<tr><td>${data[i].id}</td><td>${data[i].name}</td><td>${data[i].song}</td></tr>`; } response.end(` <html> <head> <meta charset="utf-8" /> <title></title> </head> <body> <table> <tr><td>id</td><td>name</td><td>song</td></tr> ${str} </table> <script src='127.0.0.1/变色.js'></script> </body> </html> `); }else if(pathname==='/变色.js'){ let js=fs/readFileSyns('./变色.js'); response.end(js); console.log('cssdfsafasdfsa'); }else{ response.end('404'); } } ); server.listen(80,function(){ console.log('80 '); } )

• 根据路径响应文件内容

  使用 url.parse()方法将路径解析为一个方便操作的对象。
  第二个参数为 true 表示直接将查询字符串转为一个对象（通过query属性来访问）

  发get请求 如果是/index .html 就返回 public/index.html 的内容返回

  如果是其他的就返回其他的

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  const http=require('http'); const fs=require('fs'); const url=require('url'); const server=http.createServer(function(request,response){ const pathname=(url.parse(request.url,true)).pathname; if(pathname==='/index.html'){ let html=fs.readFileSync('./index.html'); response.end(html); }else if(pathname==='/css'){ let css=fs.readFileSync(__dirname+'/css/app.css') response.end(css); }else{ response.end('ddddddddd'); } } ) server.listen(80,function(){ console.log('服务已经启动 80端口监听中'); } )

• **路径响应 **

  fs.readFile(filePath,function(err,data){

  if(err){ 404}

  else{ data}

  })