Node中的模块

发表于 | 分类于

Node中的模块

[TOC]

####常用内置对象

  • global

    而在Node.js环境中，有唯一的全局对象，叫global，这个对象的属性和方法也和浏览器环境的window不同

  • process

    代表当前Node.js进程。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    > process.version;
    'v5.2.0'
    > process.platform;
    'darwin'
    > process.arch;
    'x64'
    > process.cwd(); //返回当前工作目录
    '/Users/michael'
    > process.chdir('/private/tmp'); // 切换当前工作目录
    undefined
    > process.cwd();
    '/private/tmp'

常用内置模块

  • 文件系统模块（服务端都要使用异步方法）

    1. 异步读取文本文件

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      'use strict'
      var fs=require('fs');
      //在同级目录下的文本文件，当正常读取时，err参数为null，data参数为读取到的String。当读取发生错误时，err参数代表一个错误对象，data为undefined
      fs.readFile('hello.txt','utf-8',function(err,data){
          if(err){
              console.log(err);
          }
          else{
              console.log(data);
          }
      })

    2. 异步读取二进制文件

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      'use strict';
      var fs = require('fs');
      //当读取二进制文件时，不传入文件编码时，回调函数的data参数将返回一个Buffer对象。在Node.js中，Buffer对象就是一个包含零个或任意个字节的数组（注意和Array不同）。
      fs.readFile('sample.png', function (err, data) {
          if (err) {
              console.log(err);
          } else {
              console.log(data);
              console.log(data.length + ' bytes');
          }
      });

      Buffer对象与String对象之间的转化

      1
      2
      3
      4
      5
      6
      // Buffer -> String
      var text = data.toString('utf-8');
      console.log(text);
      // String -> Buffer
      var buf = new Buffer(text, 'utf-8');
      console.log(buf);

    3. 同步读取文件

      1
      2
      3
      4
      5
      'use strict';
      var fs = require('fs');
      //不接受回调函数，直接函数返回结果
      var data = fs.readFileSync('sample.txt', 'utf-8');
      console.log(data);

    4. 异步写文件

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      'use strict';
      var fs = require('fs');
      var data = 'Hello, Node.js';
      //如果传入的数据是String，默认按UTF-8编码写入文本文件，如果传入的参数是Buffer，则写入的是二进制文件。回调函数由于只关心成功与否，因此只需要一个err参数。
      fs.writeFile('output.txt', data, function (err) {
          if (err) {
              console.log(err);
          } else {
              console.log('ok.');
          }
      });

    5. 同步写文件

      1
      2
      3
      4
      5
      6
      'use strict';
      var fs = require('fs');
      var data = 'Hello, Node.js';
      fs.writeFileSync('output.txt', data);

    6. 通过stat获取文件的基本信息

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      'use strict';
      var fs = require('fs');
      fs.stat('sample.txt', function (err, stat) {
          if (err) {
              console.log(err);
          } else {
              // 是否是文件:
              console.log('isFile: ' + stat.isFile());
              // 是否是目录:
              console.log('isDirectory: ' + stat.isDirectory());
              if (stat.isFile()) {
                  // 文件大小:
                  console.log('size: ' + stat.size);
                  // 创建时间, Date对象:
                  console.log('birth time: ' + stat.birthtime);
                  // 修改时间, Date对象:
                  console.log('modified time: ' + stat.mtime);
              }
          }
      });

  • Stream模块

    流是一种抽象的数据结构。特点是数据是有序的，而且必须依次读取，或者依次写入，不能像Array那样随机定位。

    1. 从文本流读取文本内容

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      'use strict';
      var fs = require('fs');
      // 打开一个流:
      var rs = fs.createReadStream('hello.txt', 'utf-8');
      //data事件可能会有多次，每次的data只是一部分的数据
      rs.on('data', function (data) {
          console.log('DATA:')
          console.log(data);
      });
      rs.on('end', function () {
          console.log('END');
      });
      rs.on('error', function (err) {
          console.log('ERROR: ' + err);
      });

    2. 以流的形式写入文件

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      'use strict';
      var fs = require('fs');
      var ws1 = fs.createWriteStream('output1.txt', 'utf-8');
      ws1.write('使用Stream写入文本数据...\n');
      ws1.write('END.');
      ws1.end();
      var ws2 = fs.createWriteStream('output2.txt');
      ws2.write(new Buffer('使用Stream写入二进制数据...\n', 'utf-8'));
      ws2.write(new Buffer('END.', 'utf-8'));
      ws2.end();

    3. 通过pipe快速复制文件

      pipe()把一个文件流和另一个文件流串起来，这样源文件的所有数据就自动写入到目标文件里了

      1
      2
      3
      4
      5
      6
      7
      8
      'use strict';
      var fs = require('fs');
      var rs = fs.createReadStream('sample.txt');
      var ws = fs.createWriteStream('copied.txt');
      rs.pipe(ws);

  • Http网络模块

    1. 接受网络请求

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      'use strict';
      // 导入http模块:
      var http = require('http');
      // 创建http server，并传入回调函数:
      var server = http.createServer(function (request, response) {
          // 回调函数接收request和response对象,
          // 获得HTTP请求的method和url:
          console.log(request.method + ': ' + request.url);
          // 将HTTP响应200写入response, 同时设置Content-Type: text/html:
          response.writeHead(200, {'Content-Type': 'text/html'});
          // 将HTTP响应的HTML内容写入response:
          response.end('<h1>Hello world!</h1>');
      });
      // 让服务器监听8080端口:
      server.listen(8080);
      console.log('Server is running at http://127.0.0.1:8080/');

      ​

    ​