NodeJs常用模块详解

最新推荐文章于 2024-09-08 19:04:25 发布

fiona_0427

最新推荐文章于 2024-09-08 19:04:25 发布

阅读量634

点赞数

文章标签： node.js

本文链接：https://blog.csdn.net/fiona_0427/article/details/107011336

版权

NodeJs模块

http模块

http 模块主要是用于创建一个能够处理和响应 http 响应的服务

使用方法如下：

// 1. 引入http模块
const http = require("http");

// 2. 创建http服务 并监听端口, 这里的端口可以修改
http.createServer((request, response) => {
    response.end('hello node');
}).listen(3000);
//此时,用浏览器访问 127.0.0.1:3000 或者 localhost:3000 就可以看到 hello node, 服务开启成功了

1.request 和 response方法

request 请求对象

response 响应对象

2.获取请求信息

request.url 获取请求路径

request.httpVersion 获取协议的版本 -----以下三个试一试

request.method 获取请求的方式(get post)

request.headers 获取请求头

使用如下：

var http = require("http");
http.createServer((request, response) => {
    // 1. 获取请求的路径(就是域名后的.)
    url     = request.url;
    
    // 2. 获取 http 协议的版本
    version = request.httpVersion;

    // 3. 获取请求方式
    method  = request.method;

    // 4. 获取请求头信息(object)
    headers = request.headers;
    response.end('over');
}).listen(3000);

3.设置响应信息

response.setHeader() 设置响应头----trytry

response.write() 设置响应信息----trytry

response.end() 响应结束

使用如下:

var http = require("http");
http.createServer((request, response) => {
    // 1. 设置响应头
    response.setHeader("content-type", "text/html; charset=utf8");
    // 2. 设置响应信息
    response.write("这是响应体信息...");
    // 3. 结束响应
    response.end('<h1>响应结束</h1>');
}).listen(3000);

4.HTTP协议–MIME类型

4.1MIME的产生：

每一个 URL 都代表着一个资源对象，而当我们请求一个网页的时候，看似只请求了一个 URI（统一资源标识符），实际上这个网页可能包含多个 URI，例如图片资源的 URI 和视频资源的 URI 等。此时有些浏览器为了加快访问速度，可能会同时开多个线程去请求 URI。也就是说其实每一个 URI 都发送了一个请求报文。

而当我们的浏览器要显示或处理这些资源的时候，我们并不知道其响应的数据是什么类型的，为了区分这些资源类型，就需要用到 MIME 了。HTTP 会为每一个通过 web 传输的对象添加上 MIME 类型的数据格式标签。浏览器在读取到对应的信息后，会调用相应的程序去处理它，任何得到我们想要的结果。

当时我请求“Request URL: http://localhost:8090/”时，请求报头Headers里有这样一段：

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

Accept 表示我当前的浏览器希望接受什么类型的文件，这是请求首部，当服务器没有客户端想要的资源的媒体类型时，会返回406 Not Acceptable 响应。当然使用了 / 表示愿意接受任意类型的资源，所以应不会看到这个响应。另外，这里的 q 表示权重，权重在 0-1 之间，可以理解成客户端在这些给出的类型中，想优先接受什么类型，可以服务器就可以根据客户端的需要返回相应的资源。

如果没有，则默认为 1 。这里前面几个类型都没有标明，则默认都是 1 ，表示优先这些类型，后面的 0.9 表示前面都没有就用这个，最后的 0.8 表示如果都没有，那么任意的类型都行。

而响应报头中有：

Content-Type：text/html;chaeset=utf-8

这表示我响应的是 text/html 类型的文件，浏览器在检测到 MIME 类型后，就会相应的去解析它。

找到登陆动画的MIME：

content-type: image/gif

MIME 类型及对应文件后缀

text/html html htm shtml;
text/css css;
text/xml xml;
image/gif gif;
image/jpeg jpeg jpg;
application/javascript js;
text/plain txt;

url模块

该模块比较简单，方法也只有三个。

1. URL各部分说明

对于一个 URL 字符串，其组成部分会有所有不同，其中有些部分只有在URL字符串中存在时，对应字段才会出现在解析后对象中。以下是一个 URL 例子：

http://user:pass@host.com:8080/p/a/t/h?query=string#hash

解析后对象字段如下：

href: 解析前的完整原始 URL，协议名和主机名已转为小写
例如: “http://user:pass@host.com:8080/p/a/t/h?query=string#hash”
protocol: 请求协议，小写
例如: 'http:'
slashes: 协议的“：”号后是否有“/”
例如: `true` or `false
host: URL主机名，包括端口信息，小写
例如: `'host.com:8080'
auth: URL中的认证信息
例如: `'user:pass'
hostname: 主机名，小写
 例如: `'host.com'
port: 主机的端口号
 例如: `'8080'
 
 
---------------》》》》重点记忆pathname: URL中路径
 例如: `'/p/a/t/h'
 
 
search: 查询对象，即：`queryString`，包括之前的问号“?”
 例如: `'?query=string'
 
 
--------------》》》》》重点记忆path: `pathname` 和 `search`的合集
 例如: `'/p/a/t/h?query=string'
 
 
-------------》》》》重点记忆query`: 查询字符串中的参数部分（问号后面部分字符串），或者使用 `querystring.parse()` 解析后返回的对象
 例如: `'query=string'` or `{'query':'string'}
 
 
 
hash`: 锚点部分（即：“#”及其后的部分）
 例如: `'#hash'

2. 将URL字符串转换为对象：

url.parse(urlStr[, parseQueryString][, slashesDenoteHost])

url.parse()方法用于解析URL对象，解析后返回一个JSON对象。示例如下：

var url = require('url');

var urlString = 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash';
var result = url.parse(urlString);
console.log(result);

//输出结果如下
{ protocol: 'http:',
  slashes: true,
  auth: 'user:pass',
  host: 'host.com:8080',
  port: '8080',
  hostname: 'host.com',
  hash: '#hash',
  search: '?query=string',
  query: 'query=string',
  pathname: '/p/a/t/h',
  path: '/p/a/t/h?query=string',
  href: 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash' 
}

//第二个可选参数设置为true时，会使用querystring模块来解析URL中德查询字符串部分，默认为 false。

//输出结果如下
{ protocol: 'http:',
  slashes: true,
  auth: 'user:pass',
  host: 'host.com:8080',
  port: '8080',
  hostname: 'host.com',
  hash: '#hash',
  search: '?query=string',
  query: {query:"string"},
  pathname: '/p/a/t/h',
  path: '/p/a/t/h?query=string',
  href: 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash' 
}

//第三个可参数设置为 true时，会把诸如 //foo/bar 这样的URL解析为 { host: 'foo', pathname: '/bar' } 而不是 { pathname: '//foo/bar' }。 默认为 false。

3. 将对象格式化为URL字符串：url.format(urlObj)

url.resolve()用于格式化URL对象。输入一个 URL 对象，返回格式化后的 URL 字符串。示例如下：

var url = require('url');

var urlObj = { 
  protocol: 'http:',
    slashes: true,
    hostname: 'itbilu.com',
    port: 80,
    hash: '#hash',
    search: '?query=string',
    path: '/nodejs?query=string'
}
var result = url.format(urlObj);
console.log(result);

//输出结果如下
http://itbilu.com:80?query=string#hash
/*
*传入的URL对象会做以下处理：
*
*href 属性会被忽略
*protocol无论是否有末尾的 : (冒号)，会同样的处理
*这些协议包括 http, https, ftp, gopher, file 后缀是 :// (冒号-斜杠-斜杠).
*所有其他的协议如 mailto, xmpp, aim, sftp, foo, 等 会加上后缀 : (冒号)
*auth 如果有将会出现.
*hostname 如果 host 属性没被定义，则会使用此属性.
*port 如果 host 属性没被定义，则会使用此属性.
*host 优先使用，将会替代 hostname 和port
*pathname 将会同样处理无论结尾是否有/ (斜杠)
*search 将会替代 query属性
*query (object类型; 详细请看 querystring) 如果没有 search,将会使用此属性.
*search 无论前面是否有 ? (问号)，都会同样的处理
*hash无论前面是否有# (井号, 锚点)，都会同样处理
*/

4. URL路径处理：url.resolve(from, to)

url.resolve()方法用于处理URL路径，也可以用于处理锚点。示例如下：

url.resolve('/one/two/three', 'four')         // '/one/two/four'
url.resolve('http://example.com/', '/one')    // 'http://example.com/one'
url.resolve('http://example.com/one', '/two') // 'http://example.com/two'

querystring模块

查询字符串主要由两个方法和内置格式化方法组成，一个是将对象转换为字符串，一个则是相反，将字符串转换为对象：

1.对象转换为字符串

querystring.stringify(obj, [sep], [eq])：

将JSON对象格式化为查询字符串格式的字符串，默认的分隔符为：“&”和“=”，具体可以看一下以下代码：

querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' })

// returns
'foo=bar&baz=qux&baz=quux&corge='
querystring.stringify({foo: 'bar', baz: 'qux'}, ';', ':')
// returns
'foo:bar;baz:qux'

2.字符串转换为对象

querystring.parse(str, [sep], [eq], [options])：

根据“&”和“=”将字符串进行分割，反序列化为JSON对象，而options包含的maxKeys默认设置为1000，如果将其设置为0则表示没这个限制。

querystring.parse('foo=bar&baz=qux&baz=quux&corge')

// returns
{ foo: 'bar', baz: ['qux', 'quux'], corge: '' }

3.内置方法

querystring.escape，querystring.unescape：

这两个内置方法，分别在上述stringify，parse方法的内置使用，如果有需要分别格式化和解码URL字符串。

4.QueryString模块和Url模块之间的关系

                        url.parse(string).query
                                           |
           url.parse(string).pathname      |
                       |                   |
                       |                   |
                      ------  --------------------
http://localhost:8888/start?  foo=bar&  hello=world
                               -------    -----------
                                 |          |
                                 |          |
              querystring(string)["foo"]    |
                                            |
                         querystring(string)["hello"]

fs模块

简单理解为Node.js的文件系统的Api

//公共引用
var fs = require('fs'),
path = require('path');

1、读取文件readFile函数

//readFile(filename,[options],callback);

/**
 * filename, 必选参数，文件路径
 * [options],可选参数，可指定flag（文件操作选项，如r+ 读写；w+ 读写，文件不存在则创建）及encoding属性
 * callback 读取文件后的回调函数，参数默认第一个err,第二个data 数据
 */

fs.readFile(__dirname + '/test.txt', {flag: 'r+', encoding: 'utf8'}, function (err, data) {
    if(err) {
     console.error(err);
     return;
    }
    console.log(data);
});

关于filename文件路径的写法：

1、__dirname :

2、__filename :

3、“./” :

示例：

//server.js内容：
var path = require("path");

console.log("__dirname: "+__dirname);
console.log("__filename: "+__filename);
console.log("./: "+path.resolve("./"));


//在E:\zpy>运行命令：
E:\zpy>node server.js

//运行结果：
__dirname: E:\zpy
__filename: E:\zpy\server.js
./: E:\zpy

小结：

__dirname: 返回js所在文件夹的绝对路径
__filename: 返回被执行的 js 的绝对路径
./: 返回执行 node 命令的绝对路径（node命令所执行的目录）

2、写文件writeFile函数

// fs.writeFile(filename,data,[options],callback);
var w_data = '这是一段通过fs.writeFile函数写入的内容；\r\n';
var w_data = new Buffer(w_data);

/**
 * filename, 必选参数，文件名
 * data, 写入的数据，可以字符或一个Buffer对象
 * [options],flag,mode(权限),encoding
 * callback 读取文件后的回调函数，参数默认第一个err,第二个data 数据
 */

fs.writeFile(__dirname + '/test.txt', w_data, {flag: 'a'}, function (err) {
   if(err) {
    console.error(err);
    } else {
       console.log('写入成功');
    }
});

3、以追加方式写文件appendFile函数

// fs.appendFile(filename,data,[options],callback);

fs.appendFile(__dirname + '/test.txt', '使用fs.appendFile追加文件内容', function () {
  console.log('追加内容完成');
});

4、打开文件open函数

// fs.open(filename, flags, [mode], callback);

/**
 * filename, 必选参数，文件名
 * flags, 操作标识，如"r",读方式打开
 * [mode],权限，如777，表示任何用户读写可执行
 * callback 打开文件后回调函数，参数默认第一个err,第二个fd为一个整数，表示打开文件返回的文件描述符，window中又称文件句柄
 */

fs.open(__dirname + '/test.txt', 'r', '0666', function (err, fd) {
  console.log(fd);
});

5、读文件，读取打开的文件内容到缓冲区中；

//fs.read(fd, buffer, offset, length, position, callback);
/**
 * fd, 使用fs.open打开成功后返回的文件描述符
 * buffer, 一个Buffer对象，v8引擎分配的一段内存
 * offset, 整数，向缓存区中写入时的初始位置，以字节为单位
 * length, 整数，读取文件的长度
 * position, 整数，读取文件初始位置；文件大小以字节为单位
 * callback(err, bytesRead, buffer), 读取执行完成后回调函数，bytesRead实际读取字节数，被读取的缓存区对象
 */

fs.open(__dirname + '/test.txt', 'r', function (err, fd) {
  if(err) {
    console.error(err);
    return;
  } else {
    var buffer = new Buffer(255);
    console.log(buffer.length);
    //每一个汉字utf8编码是3个字节，英文是1个字节
    fs.read(fd, buffer, 0, 9, 3, function (err, bytesRead, buffer) {
      if(err) {
        throw err;
      } else {
        console.log(bytesRead);
        console.log(buffer.slice(0, bytesRead).toString());
        //读取完后，再使用fd读取时，基点是基于上次读取位置计算；
        fs.read(fd, buffer, 0, 9, null, function (err, bytesRead, buffer) {
          console.log(bytesRead);
          console.log(buffer.slice(0, bytesRead).toString());
        });
      }
    });
  }
});