NodeJs学习之API篇

学习nodeJS的API在对于使用nodeJS来进行编程的是十分重要的，所以首先就要去学习看看，相关的node的模块，来看一看相关的内容和可用性。

正文篇：

　　nodeJS的API学习之路。(这里我们将会简要的介绍一些nodeJS中稳定性较高的API，当然还有一些其他的稳定性不个哦的内容这里就不写了。)

• Assert模块
• Addons插件
• Buffer
• Child Process(子进程)

　　（1）Assert模块

　　安全等级：其本身是nodeJS中的锁定模块，稳定性是最高的，认定为不会被修改。

　　模块作用：用于测试数据的不变性。

　　提供方法：

• • assert(value[,message])：与assert.ok()相同

• • • value：需要测试的值，例如false，ture，或是数字等等。
    • message：如果判断不正确抛出的错误信息是什么。
    • 代码如下:

       var assert = require("assert");
      
       assert(true);    //ok
       assert(1);        //ok
      
       assert(0);
           //throw "assertionError: 0 == true";
       assert(false, it is false);
           //throw "assertionError: it is false";

  • assert.deepEqual(actual, experts[,message])：在比对的时候，如果对象数据中有艺术性也是对象，那么深层的对象也会进行比对，只有当两变量可枚举属性完全可相等的时候才会判定为true。
  • actual:需要比对的值
  • experts:预期相等的值
  • message：希望报错时抛出的信息
  • 代码如下：

  • var a = {a:{b:1}};
    var b = {a:{b:1}};
    var c = {a:{b:2}};
    var d = Object.create(a);
    
    assert.deepEqual(a, b);  //OK;
    assert.deepEqual(a, c);  // throw "assertError: "{a:{b:1}} deepEqual {a:{b:2}}
    assert.deepEqual(a, d);  // throw "assertError: "{a:{b:1}} deepEqual {}　　

  • assert.deepStrictEqual(actual, experts[,message])：与deepEqual类似，只是使用强等于（===）来比较实际值和预期值
    • actual:需要比较的实际值
    • experts：需要比较的预期值
    • message：同上
    • 代码如下：

       assert.deepEqual({a:1}, {a:"1"}); // ok
      
       assert.deepStrictEqual({a:1}, {a:"1"}); // throw AssertionError 1 !== ‘1’

  • assert.doesNotThrow(block[,error[,message]])：block函数块中如果抛出的异常和error中传入的异常类型相同，则将当前的异常给予调用者，如果error没有传入参数，或者是block中抛出的异常类型和给的异常类型不相同，则直接抛出异常
    • block：函数块，其中有异常抛出
    • error：异常的类型
    • message：同上
    • 代码如下：

      assert.doesNotThrow(()=>{throw new TypeError("...")}, SyntaxError);  //由于类型不相同，所以会抛出错误。
      
      assert.doesNotThrow(()=>{throw new TypeError("...")}, TypeError);  //由于类型相同，错误返回给调用者。

  • assert.equal(actual,experts[,message])：断言实际值与预期值是否相同。使用的是浅等于即“==”.
    • actual:需要比较的实际值
    • experts：比较的预期值
    • message：同上
    • 代码如下：

      assert.equal(1, "1"); //ok

  • assert.fail(acutal,experts,message,operator):直接抛出异常，如果没有message内容的话，这通过其他3个参数来进行组合，组合的方式是acutal operator experts，有message参数的话则直接使用message。
    • acutal：比较的值之一
    • experts：预期的值。
    • message：error的显示信息
    • operator：相关的操作是什么
    • 代码如下：

      assert.fail(1, 2, undefined, ">"); // throw AssertionError: 1 > 2
      assert.fail(1, 2, "wrong", ">"); //thrwo AssertionError: wrong

  • assert.ifError(value):如果value是真值的话，就抛出异常。
    • value：任意变量或是直接量
    • 代码如下：

      const assert = require('assert');
      
      assert.ifError(0); // OK
      assert.ifError(1); // Throws 1
      assert.ifError('error') // Throws 'error'
      assert.ifError(new Error()); // Throws Error

  • assert.notDeepEqual(actual,experts[,message])：获得的结果与深度相同（deepEqual）函数获取的值相反。即deepEqual为真则当前函数则抛出异常。
    • actual:需要比较的真实值
    • experts：比较的预期值
    • message：同上
    • 代码如下:

      const assert = require('assert');
      
      const obj1 = {a : {b : 1}};
      const obj2 = {a : {b : 2}};
      const obj3 = {a : {b : 1}};
      const obj4 = Object.create(obj1);
      
      assert.notDeepEqual(obj1, obj1);// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
      assert.notDeepEqual(obj1, obj2);// OK, obj1 and obj2 are not deeply equal
      assert.notDeepEqual(obj1, obj3);// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
      assert.notDeepEqual(obj1, obj4);// OK, obj1 and obj2 are not deeply equal

  assert.notDeepStrictEqual(acutal,experts[.message]):强不等号（!==!）比较，不成立的话则抛出异常

  • actual：需要比较的数据
  • experts：预期不相等的数据
  • messge：同上
  • 代码如下：

    const assert = require('assert');
    
    assert.notDeepEqual({a:1}, {a:'1'}); // AssertionError: { a: 1 } notDeepEqual { a: '1' }
    
    assert.notDeepStrictEqual({a:1}, {a:'1'}); // OK

  • assert.notEqual(actual,experts[,messsage])：浅不等于比较两者之间的值，如果两值相同则，抛出异常。
    • actual：需要比较的数据
    • experts：与其不相同的数据
    • message：同上
    • 代码如下：

      const assert = require('assert');
      
      assert.notEqual(1, 2); // OK
      
      assert.notEqual(1, '1'); // AssertionError: 1 != '1'

  • assert.notStrictEqual(actual,experts[,message])：强不等于比较两个传入的参数，如果两值不相同的话我们将会抛出异常。
    • actual：需要比较的值
    • experts：预期不相等的值
    • message：同上：
    • 代码如下：

      const assert = require('assert');
      
      assert.notStrictEqual(1, 2);  // OK
      assert.notStrictEqual(1, 1);  // AssertionError: 1 != 1
      assert.notStrictEqual(1, '1');  // OK

  • assert.ok(value)：上面我们已将说过了assert传入参数直接可以判断，且救国救和当前函数相同。
    • value：任意变量和直接量
    • 代码如下：

      const assert = require('assert');
      
      assert.ok(true);  // OK
      assert.ok(1);     // OK
      assert.ok(false);
        // throws "AssertionError: false == true"
      assert.ok(0);
        // throws "AssertionError: 0 == true"
      assert.ok(false, 'it\'s false');
        // throws "AssertionError: it's false”

  • assert.strictEqual(actual,experts[,message])：强等于好判断两值之间的相同与否，两值不相同的话则抛出异常。
    • actual：实际比较值
    • experts：预期相等值
    • message：异常抛出时附带的信息
    • 代码如下：

      const assert = require('assert');
      
      assert.strictEqual(1, 2); // AssertionError: 1 === 2
      assert.strictEqual(1, 1); // OK
      assert.strictEqual(1, '1'); // AssertionError: 1 === '1'

  • assert.throws(block[,error[,message]])：通过error来测试是否block处的异常的信息是否与预期不相同，如果与预期不相同则抛出异常，如果相同的话则不抛出。
    • block：含有异常抛出内容的函数块。
    • error：可以是构造函数，或是regExp，或者是一个判断函数，用于判断当前的block中的抛出异常的信息。但是不可以为String类型的数据，注意。
    • message：同上
    • 代码如下：

      assert.throws(
        () => {
          throw new Error('Wrong value');
        },
        function(err) {
          if ( (err instanceof Error) && /value/.test(err) ) {
            return true;
          }
        },
        'unexpected error'
      );

　（2）Addons插件

　　Addons插件实际上是动态链接库。其中可以使用C，C++和JS，其中的API相对复杂，设计到多个类库的运用。

1. 1. V8 JavaScript引擎,一个 C++ 类库. 用于和JavaScript进行交互的接口。 创建对象, 调用函数等. 文档大部分在这里： v8.h 头文件 (deps/v8/include/v8.h在Node源代码目录里), 也有可用的线上文档 线上. （译者：想要学习c++的addons插件编写，必须先了解v8的接口）
   2. libuv, C语言编写的事件循环类库。任何时候需要等待一个文件描述符变为可读状态，等待一个定时器，或者等待一个接受信号都需要使用libuv类库的接口。也就是说，如果你执行任何I/O操作，libuv类库将会被用到。
   3. 内部 Node 类库.最重要的接口就是 node::ObjectWrap 类，这个类你应该是最可能想要派生的。
   4. 其他.请参阅 deps/ 获得更多可用类库。

　　Node 静态编译了所有依赖到它的可执行文件中去了。当编译你的模块时，你不必担心无法连接上述那些类库。 （译者：换而言之，你在编译自己的addons插件时，只管在头部 #include <uv.h>，不必在binding.gyp中声明）

　　（3）Buffer模块

　　这是少几个不需要引入而可以直接使用的模块了。其模块稳定性呗nodeJS评价为二等级（稳定）

　　这个对象是node专门打造出来为了改善js不擅长处理二进制文件信息的特性的。相关的字符编码的知识请点击这里。

　　之前的版本中常常使用new Buffer()这样的形式来进行新对象的使命和使用，但是新版本中不竟然，说是为了避免某些错误而修改了。现在的方法变成了Buffer.from()，Buffer.alloc()，和Buffer.allocUnsafe()，下面我们来分别说一说这些API。

• • Buffer.from(array):分配一个新的Buffer对象，其中函授的数据是提供的八位字节数组的拷贝。
    • array：是一个存有八位字节数据(ASXII码)的数组，例如：[0x62, 0x75, 0x66, 0x66, 0x65, 0x72]

    • 代码如下：

      // Creates a new Buffer containing ASCII bytes of the string 'buffer'
      const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
      // 需要注意的是，当array不是一个Array对象的时候。

  • Buffer.from(ArrayBuffer[,byteOffset[,length]]):当传入一个TypedArray实例的.buffer属性的映射给当前函数，新创建的buffer对象将会与TypedArray共享分配的内存块。
    • ArrayBuffer：传入的创造Buffer对象的而参数的组要数据。
    • byteOffset：从数组内容的第几号索引进行检索复制，默认是0；
    • length：需要拷贝的内容长度是多少的，默认和数组本身长度相同。
    • 代码如下：

      const arr = new Uint16Array(2);
      
      arr[0] = 5000;
      arr[1] = 4000;
      
      // Shares memory with `arr`
      const buf = Buffer.from(arr.buffer);
      
      // Prints: <Buffer 88 13 a0 0f>
      console.log(buf);
      
      // Changing the original Uint16Array changes the Buffer also
      arr[1] = 6000;
      
      // Prints: <Buffer 88 13 70 17>
      console.log(buf);

  • Buffer.from(buffer):传入一个buffer对象来进行值得拷贝，然后返回一个新的buffer对象。
    • buffer：一个存在的buffer对象。
    • 代码如下：

      var assert = require("assert");
      
      const buf = Buffer.from("bufferTest");
      const buf2= Buffer.from(buf);
      
      console.log(buf);
      console.log(buf);
      
      try{
          assert.equal(buf,buf2);
      }catch(e){
          console.log(e);
      }
      
      try{
          assert.strictEqual(buf,buf2);
      }catch(e){
          console.log(e); //generate message:true;
      }
      
      try{
          assert.strictEqual({},{});
      }catch(e){
          console.log(e);  //generate message:true;
      }
      
      buf[0] = 0x61;
      
      console.log(buf.toString()); //aufferTest
      console.log(buf2.toString()); //bufferTest

  • Buffer.from(string[,encoding]):传入相关的字符串内容和编码格式信息，返回一个新的buffer对象。
    • string：提供字符串内容来创建buffer对象。
    • encoding：为字符串编码，默认的情况是UTF-8。
    • 代码如下：

      const buf1 = Buffer.from('this is a tést');
      // Prints: this is a tést
      console.log(buf1.toString());
      // Prints: this is a tC)st
      console.log(buf1.toString('ascii'));
      
      const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
      // Prints: this is a tést
      console.log(buf2.toString());

　　　　当然buffer还提供了一些其他的常用的API

• • Buffer.isBuffer(obj):检测当前的对象是不是buffer对象
    • obj：传入一个对象，进行判断。
  • Buffer.isEncoding(encoding):如果是支持的格式则返回true，否则为false。
    • encoding：编码格式。
  • Buffer.poolSize:内部的Buffer实例使用的就是池的概念，这一数据表示的是预设的池的大小，可以修改。

　　Buffer对象上的所需要注意的API就如上所说，因为是新修改的而且在我们使用的过程中十分的重要，之后对于实例可用的方法就不一一介绍了，因为和我们平常使用的操作十分的相像，具体可以参见API文档中的Buffer一章节的内容。

　　这里在说明一下TypeArray和ArrayBuffer：

• • TypedArray 对象表示底层的二进制数据缓存区的类数组视图. 没有名为 TypedArray 的全局属性，也不存在直接可见的 TypedArray 构造器。相反，有若干不同的全局属性的值是类型数组的特殊构造器（typed array constructors for specific element types），用于特定的元素类型，这些在下文有列出。接下来，会介绍能和任何包含任意类型元素的类型数组一起使用的通用属性和方法。
    • 代码如下：

       new TypedArray(length);
       new TypedArray(typedArray);
       new TypedArray(object);
       new TypedArray(buffer [, byteOffset [, length]]); 
      
       以下皆是 TypedArray() : 
      
       Int8Array();
       Uint8Array();
       Uint8ClampedArray();
       Int16Array();
       Uint16Array();
       Int32Array();
       Uint32Array();
       Float32Array();
       Float64Array();

  • ArrayBuffer（缓冲数组）是一种用于呈现通用、固定长度的二进制数据的类型。

　　　　　　　　

　　（4）Child Process子进程

　　 子进程模块中提供创建子进程的方法体系，其中方法相似但是不相同，但是多事源于child_process.spwan()这一方法。

const spawn = require('child_process').spawn;
const ls = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

ls.stderr.on('data', (data) => {
  console.log(`stderr: ${data}`);
});

ls.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});

　　其中的stdin,stdout,stderr是在nodeJS中的主进程和子进程之间的通信渠道，有可能实现两者之间的非阻塞通信。有些程序使用的是缓冲I/O实例，但是这并不印象到nodeJS，它可能意味着送往子进程的数据并不会马上就被处理。

　　child_process.spawn()方法同步的创建子进程，并不会影响到NodeJs中的事件循环。

　　child_process.spawnSync()方法以异步的形式创建子进程。

　　当然在子进程模块中也是有其的进程创建的方法可以使用的但是，在它们实际上都是紧跟了上述两个函数的内容的。

　　我们先来看几个相关的函数吧。

• • child_process.exec(command[,options][,callback]):分配一个单独区域并执行相关的命令。
    • command：string类型的命令行。
    • options：是一个对象，对象中包含内容如下：
    • callback: 当子进程结束的时候