(75)Wangdao.com第十三天_JavaScript 包装对象

包装对象

所谓“包装对象”，就是分别与数值、字符串、布尔值相对应的Number、String、Boolean三个原生对象

这三个原生对象可以把原始类型的值变成（包装成）对象

• • var v1 = new Number(123);
    var v2 = new String('abc');
    var v3 = new Boolean(true);
    
    typeof v1    // "object"
    typeof v2    // "object"
    typeof v3    // "object"
    
    v1 === 123    // false
    v2 === 'abc'    // false
    v3 === true    // false

• 目的：
  • 使得 JavaScript 的对象涵盖所有的值
  • 使得原始类型的值可以方便地调用某些方法

• 实例方法 : 
  • • 三种包装对象各自提供了许多实例方法。这里介绍两种它们共同具有、从Object对象继承的方法：valueOf和toString
  • .valueOf()    返回包装对象实例对应的原始类型的值
  • .toString()    方法返回对应的字符串形式

  • new Number(123).valueOf();     //
    new String('abc').valueOf();    // "abc"
    new Boolean(true).valueOf();    // true
    
    new Number(123).toString();    // "123"
    new String('abc').toString();    // "abc"
    new Boolean(true).toString();    // "true"

• 原始类型与实例对象的自动转换 : 
  • 原始类型的值，可以自动当作包装对象调用，即调用包装对象的属性和方法。
  • 这时，JavaScript 引擎会自动将原始类型的值转为包装对象实例，在使用后立刻销毁实例

  • 'abc'.length    //
    
    // abc是一个字符串，本身不是对象，不能调用length属性。
    // JavaScript 引擎自动将其转为包装对象，在这个对象上调用length属性。
    // 调用结束后，这个临时对象就会被销毁。
            //这就叫原始类型与实例对象的自动转换

  • 调用结束后，包装对象实例会自动销毁。
  • 这意味着，下一次调用字符串的属性时，实际是调用一个新生成的对象，而不是上一次调用时生成的那个对象，所以取不到赋值在上一个对象的属性。
  • 如果要为字符串添加属性，只有在它的原型对象String.prototype上定义

• 自定义方法 : 
• 除了原生的实例方法，包装对象还可以自定义方法和属性，供原始类型的值直接调用

  • // 比如，我们可以新增一个double方法，使得字符串和数字翻倍
    String.prototype.double = function () {
        return this.valueOf() + this.valueOf();
    };
    
    'abc'.double();    // abcabc
    
    Number.prototype.double = function () {
        return this.valueOf() + this.valueOf();
    };
    
    (123).double();    // 246    123外面必须要加上圆括号，否则后面的点运算符（.）会被解释成小数点

• 这种自定义方法和属性的机制，只能定义在包装对象的原型上，如果直接对原始类型的变量添加属性，则无效

Boolean 对象

• 作为构造函数时，它主要用于生成布尔值的包装对象实例
  • false对应的包装对象实例，布尔运算结果也是true

  • var b = new Boolean(true);
    
    typeof b;    // "object"
    b.valueOf();    // true
    
    if (new Boolean(false)) {
        console.log('true');    // true
    } 
    
    if (new Boolean(false).valueOf()) {
        console.log('true');    // 无输出
    } 

• 作为函数单独使用，将任意值转为布尔值

  • Boolean(undefined);     // false
    Boolean(null);     // false
    Boolean(0);     // false
    Boolean('');     // false
    Boolean(NaN);     // false
    
    Boolean(1);     // true
    Boolean('false');     // true
    Boolean([]);     // true
    Boolean({});    // true
    Boolean(function () {});    // true
    Boolean(/foo/);    // true
    
    // 上面几种 true 的情况，都值得认真记住

  • 使用双重的否运算符（!）也可以将任意值转为对应的布尔值

    !!undefined    // false
    !!null    // false
    !!0    // false
    !!''    // false
    !!NaN    // false
    
    !!1    // true
    !!'false'    // true
    !![]    // true
    !!{}    // true
    !!function(){}    // true
    !!/foo/    // true

Number 对象

是数值对应的包装对象，可以作为构造函数使用，也可以作为工具函数使用

• var n = new Number(1);
  typeof n    // "object"
  
  Number(true);    //

• 作为构造函数时，它用于生成值为数值的对象
• 作为工具函数时，它可以将任何类型的值转为数
• 静态属性
  • Number.POSITIVE_INFINITY        正的无限，指向Infinity
  • Number.NEGATIVE_INFINITY        负的无限，指向-Infinity
  • Number.NaN        表示非数值，指向NaN
  • Number.MIN_VALUE        表示最小的正数（即最接近0的正数，在64位浮点数体系中为5e-324），相应的，最接近0的负数为-Number.MIN_VALUE
  • Number.MAX_SAFE_INTEGER        表示能够精确表示的最大整数，即9007199254740991
  • Number.MIN_SAFE_INTEGER       表示能够精确表示的最小整数，即-9007199254740991

• 四个实例方法        都跟将数值转换成指定格式有关
  • Number.prototype.toString()
    • Number对象部署的自己的toString方法，用来将一个数值转为字符串形式
    • 可以接受一个参数，表示输出的进制。
    • 如果省略这个参数，默认将数值先转为十进制，再输出字符串；
    • 否则，就根据参数指定的进制，将一个数字转化成某个进制的字符串

      • // 10一定要放在括号里，这样表明后面的点表示调用对象属性。
        // 如果不加括号，这个点会被 JavaScript 引擎解释成小数点，从而报错
        
        (10).toString();    // "10"
        
        (10).toString(2);     // "1010"
        (10).toString(8);     // "12"
        (10).toString(16);     // "a"

    • 通过方括号运算符也可以调用toString方法

      • 10['toString'](2);    // "1010"

  • Number.prototype.toFixed()    先将一个数转为指定位数的小数，然后返回这个小数对应的字符串

    • • (10).toFixed(2);    // "10.00"
        (10.005).toFixed(2);    // "10.01"
        11.11111.toFixed(2);    // "11.11"

        参数为小数位数，有效范围为0到20，超出这个范围将抛出 RangeError 错误

  • Number.prototype.toExponential()    用于将一个数转为科学计数法形式

    • (10).toExponential();      // "1e+1"
      (10).toExponential(1);     // "1.0e+1"
      (10).toExponential(2);     // "1.00e+1"
      
      (1234).toExponential();    // "1.234e+3"
      (1234).toExponential(1);     // "1.2e+3"
      (1234).toExponential(2);     // "1.23e+3"

      小数点后有效数字的位数，范围为0到20，超出这个范围，会抛出一个 RangeError 错误

  • Number.prototype.toPrecision()    将一个数转为指定位数的有效数字

    • (12.34).toPrecision(1);     // "1e+1"
      (12.34).toPrecision(2);     // "12"
      (12.34).toPrecision(3);     // "12.3"
      (12.34).toPrecision(4);     // "12.34"
      (12.34).toPrecision(5);     // "12.340"

      有效数字的位数，范围是1到21，超出这个范围会抛出 RangeError 错误

    • 不会进行四舍五入，而是类似向下取整

      (12.35).toPrecision(3);     // "12.3"
      (12.25).toPrecision(3);     // "12.3"
      (12.15).toPrecision(3);     // "12.2"
      (12.45).toPrecision(3);     // "12.4"

• 自定义方法
  • 与其他对象一样，Number.prototype对象上面可以自定义方法，被Number的实例继承。
  • 在数值上调用某个方法，数值会自动转为Number的实例对象
  • 如果方法返回的还是数值，还可以进行链式运算

    • Number.prototype.add = function (x) {
          return this + x;
      };
      
      Number.prototype.subtract = function (x) {
          return this - x;
      };
      
      8['add'](2);    //
      (8).add(2).subtract(4);    //

  • 部署更复杂的方法

    • // 在Number对象的原型上部署了iterate方法，将一个数值自动遍历创建一个数组
      Number.prototype.iterate = function () {
          var result = [];
          for (var i = 0; i <= this; i++) {
              result.push(i);
          }
          return result;    // 返回创建的数组
      };
      
      (8).iterate()    // [0, 1, 2, 3, 4, 5, 6, 7, 8]

String 对象

• • • var s1 = 'abc';
      var s2 = new String('abc');
      
      typeof s1;   // "string"
      typeof s2;    // "object"
      
      s2.valueOf();    // "abc"
      

      new String('abc');    // String {0: "a", 1: "b", 2: "c", length: 3}
      
      (new String('abc'))[1];    // "b"    有数值键（0、1、2）和length属性，所以可以像数组那样取值

      字符串对象是一个类似数组的对象（很像数组，但不是数组）

    • 除了用作构造函数，String对象还可以当作工具方法使用，将任意类型的值转为字符串
• 静态方法
  • String.fromCharCode()
    • 参数是一个或多个数值，代表 Unicode 码点，返回值是这些码点组成的字符串
    • 参数为空，就返回空字符串；否则，返回参数对应的 Unicode 字符串
    • 该方法不支持 Unicode 码点大于0xFFFF的字符，即传入的参数不能大于0xFFFF（即十进制的 65535 )
    • 参数0x20BB7大于0xFFFF，导致返回结果出错。。。注意：是结果出错，而不是报错
    • 码点大于0xFFFF的字符占用四个字节，而 JavaScript 默认支持两个字节的字符。这种情况下，必须把0x20BB7拆成两个字符表示

      • String.fromCharCode(0xD842, 0xDFB7);    // "