美文网首页
(10)内置对象-2

(10)内置对象-2

作者: 汨逸 | 来源:发表于2019-05-26 22:49 被阅读0次

    内置对象(2)

    我们平时忙于开发,很少有时间能够将文档看一遍。这样在很多时候,我们本可以一个原生方法能够实现的程序,却累的跟狗一样,写出来的程序还不定好使。为了减少重复造轮子的时间,将MDN的API结合自己的理解,归纳整理了下面的文档。MDN文档-JavaScript内置对象

    7. Object

    let obj = new Object;
    

    Object 构造函数创建一个对象包装器。

    Object构造函数的属性:

    1. Object.length: 值为1
    2. Object.prototype: 为所有的Object类型的对象添加属性。

    Object构造函数的方法:

    1. Object.assign(target, source): 通过复制一个或多个对象来创建一个新的对象。

      const target = { a: 1, b: 2 };
      const source = { b: 4, c: 5 };
      
      const returnedTarget = Object.assign(target, source);
      
      console.log(target);
      // 输出: Object { a: 1, b: 4, c: 5 }
      
      console.log(returnedTarget);
      // 输出: Object { a: 1, b: 4, c: 5 }
      
    1. Object.create(proto, [propertiesObject]): 使用指定的原型对象和属性创建一个新对象。

      const person = {
        isHuman: false,
        printIntroduction: function () {
          console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
        }
      };
      
      const me = Object.create(person);
      
      me.name = "Matthew"; // "name" is a property set on "me", but not on "person"
      me.isHuman = true; // inherited properties can be overwritten
      
      me.printIntroduction();
      // 输出: "My name is Matthew. Am I human? true"
      

      使用object.create()实现单继承和多继承

      function MyClass() {
           SuperClass.call(this);
           OtherSuperClass.call(this);
      }
      
      // 继承一个类
      MyClass.prototype = Object.create(SuperClass.prototype);
      // 混合其它
      Object.assign(MyClass.prototype, OtherSuperClass.prototype);
      // 重新指定constructor
      MyClass.prototype.constructor = MyClass;
      
      MyClass.prototype.myMethod = function() {
           // do a thing
      };
      
    1. Object.defineProperty(): 给对象添加一个属性并指定该属性的配置。

      var person = {};
      Object.defineProperty(person, "name", {
          writable: true,  // 是否可修改
          configurable: false, // 是否可以删除属性
          enumerable: true,    // 是否可以枚举属性
          value: 'Modeest',    // 设定name的值
          get: function () {   // 获取name调用的钩子
              return this.name;
          },
          set: function (newValue) {   // 修改name调用的钩子
              if (newValue === 'Modeest') {
               this.name = 'modeest-1';
              }
          }
      })
      
      注意:
      1. 默认情况下,上述的writable,configurable,enumerable都为false
      2. 上述属性如果设置为false,在非严格模式下忽略,在严格模式下报错
      3. 定义属性的configurable为false,再调用defineProperty修改configurable时也会直接报错
      
    1. Object.defineProperties(): 给对象添加多个属性并分别指定它们的配置。

      var person = {};
      Object.defineProperties(person, {
          name: {
              value: 'modeest'
          },
          age: {
              value: 18
          }
      })
      
    1. Object.entries(): 返回给定对象自身可枚举属性的 [key, value] 数组。

      const object1 = { foo: 'bar', baz: 42 };
      console.log(Object.entries(object1)[1]);
      // 输出: Array ["baz", 42]
      
      const object2 = { 0: 'a', 1: 'b', 2: 'c' };
      console.log(Object.entries(object2)[2]);
      // 输出: Array ["2", "c"]
      
      const result = Object.entries(object2).sort((a, b) => a - b);
      console.log(Object.entries(result)[1]);
      // 输出: Array ["1", Array ["1", "b"]]
      
    1. Object.freeze(): 冻结对象:其他代码不能删除或更改任何属性。

      const obj = {
        prop: 42
      };
      
      Object.freeze(obj);
      
      obj.prop = 33;
      // Throws an error in strict mode
      
      console.log(obj.prop);
      // expected output: 42
      

      注意:

      1. 一个被冻结的对象再也不能被修改;
      2. 冻结了一个对象则不能向这个对象添加新的属性,不能删除已有属性,不能修改该对象已有属性的可枚举性、可配置性、可写性,以及不能修改已有属性的值。
      3. 冻结一个对象后该对象的原型也不能被修改。freeze() 返回和传入的参数相同的对象。
    1. Object.getOwnPropertyDescriptor(): 返回对象指定的属性配置。

      Object.getOwnPropeertyDescriptor(person, 'name');
      
    1. Object.getOwnPropertyNames(): 返回一个数组,它包含了指定对象所有的可枚举或不可枚举的属性名。

      var arr = ["a", "b", "c"];
      console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"]
      
      // 类数组对象
      var obj = { 0: "a", 1: "b", 2: "c"};
      console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"]
      
    1. Object.getOwnPropertySymbols(): 返回一个数组,它包含了指定对象自身所有的符号属性。

    2. Object.getPrototypeOf(): 返回指定对象的原型对象。

      const prototype1 = {};
      const object1 = Object.create(prototype1);
      
      console.log(Object.getPrototypeOf(object1) === prototype1);
      // expected output: true
      
    1. Object.is(): 比较两个值是否相同。所有 NaN 值都相等(这与==和===不同)。

      Object.is('foo', 'foo');     // true
      Object.is(window, window);   // true
      
      Object.is('foo', 'bar');     // false
      Object.is([], []);           // false
      
      var foo = { a: 1 };
      var bar = { a: 1 };
      Object.is(foo, foo);         // true
      Object.is(foo, bar);         // false
      
      Object.is(null, null);       // true
      
      // 特例
      Object.is(0, -0);            // false
      Object.is(0, +0);            // true
      Object.is(-0, -0);           // true
      Object.is(NaN, 0/0);         // true
      
    1. Object.isExtensible(): 判断对象是否可扩展。

      // 新对象默认是可扩展的.
      var empty = {};
      Object.isExtensible(empty); // === true
      
      // ...可以变的不可扩展.
      Object.preventExtensions(empty);
      Object.isExtensible(empty); // === false
      
      // 密封对象是不可扩展的.
      var sealed = Object.seal({});
      Object.isExtensible(sealed); // === false
      
      // 冻结对象也是不可扩展.
      var frozen = Object.freeze({});
      Object.isExtensible(frozen); // === false
      
    1. Object.isFrozen(): 判断对象是否已经冻结。

      // 一个对象默认是可扩展的,所以它也是非冻结的.
      Object.isFrozen({}); // === false
      
      // 一个不可扩展的空对象同时也是一个冻结对象.
      var vacuouslyFrozen = Object.preventExtensions({});
      Object.isFrozen(vacuouslyFrozen) //=== true;
      
      // 一个非空对象默认也是非冻结的.
      var oneProp = { p: 42 };
      Object.isFrozen(oneProp) //=== false
      
      // 让这个对象变的不可扩展,并不意味着这个对象变成了冻结对象,
      // 因为p属性仍然是可以配置的(而且可写的).
      Object.preventExtensions(oneProp);
      Object.isFrozen(oneProp) //=== false
      
      // ...如果删除了这个属性,则它会成为一个冻结对象.
      delete oneProp.p;
      Object.isFrozen(oneProp) //=== true
      
      // 一个不可扩展的对象,拥有一个不可写但可配置的属性,则它仍然是非冻结的.
      var nonWritable = { e: "plep" };
      Object.preventExtensions(nonWritable);
      Object.defineProperty(nonWritable, "e", { writable: false }); // 变得不可写
      Object.isFrozen(nonWritable) //=== false
      
      // 把这个属性改为不可配置,会让这个对象成为冻结对象.
      Object.defineProperty(nonWritable, "e", { configurable: false }); // 变得不可配置
      Object.isFrozen(nonWritable) //=== true
      
      // 一个不可扩展的对象,拥有一个不可配置但可写的属性,则它仍然是非冻结的.
      var nonConfigurable = { release: "the kraken!" };
      Object.preventExtensions(nonConfigurable);
      Object.defineProperty(nonConfigurable, "release", { configurable: false });
      Object.isFrozen(nonConfigurable) //=== false
      
      // 把这个属性改为不可写,会让这个对象成为冻结对象.
      Object.defineProperty(nonConfigurable, "release", { writable: false });
      Object.isFrozen(nonConfigurable) //=== true
      
      // 一个不可扩展的对象,值拥有一个访问器属性,则它仍然是非冻结的.
      var accessor = { get food() { return "yum"; } };
      Object.preventExtensions(accessor);
      Object.isFrozen(accessor) //=== false
      
      // ...但把这个属性改为不可配置,会让这个对象成为冻结对象.
      Object.defineProperty(accessor, "food", { configurable: false });
      Object.isFrozen(accessor) //=== true
      
      // 使用Object.freeze是冻结一个对象最方便的方法.
      var frozen = { 1: 81 };
      Object.isFrozen(frozen) //=== false
      Object.freeze(frozen);
      Object.isFrozen(frozen) //=== true
      
      // 一个冻结对象也是一个密封对象.
      Object.isSealed(frozen) //=== true
      
      // 当然,更是一个不可扩展的对象.
      Object.isExtensible(frozen) //=== false
      
    1. Object.isSealed(): 判断对象是否已经密封。

      // 新建的对象默认不是密封的.
      var empty = {};
      Object.isSealed(empty); // === false
      
      // 如果你把一个空对象变的不可扩展,则它同时也会变成个密封对象.
      Object.preventExtensions(empty);
      Object.isSealed(empty); // === true
      
      // 但如果这个对象不是空对象,则它不会变成密封对象,因为密封对象的所有自身属性必须是不可配置的.
      var hasProp = { fee: "fie foe fum" };
      Object.preventExtensions(hasProp);
      Object.isSealed(hasProp); // === false
      
      // 如果把这个属性变的不可配置,则这个对象也就成了密封对象.
      Object.defineProperty(hasProp, "fee", { configurable: false });
      Object.isSealed(hasProp); // === true
      
      // 最简单的方法来生成一个密封对象,当然是使用Object.seal.
      var sealed = {};
      Object.seal(sealed);
      Object.isSealed(sealed); // === true
      
      // 一个密封对象同时也是不可扩展的.
      Object.isExtensible(sealed); // === false
      
      // 一个密封对象也可以是一个冻结对象,但不是必须的.
      Object.isFrozen(sealed); // === true ,所有的属性都是不可写的
      var s2 = Object.seal({ p: 3 });
      Object.isFrozen(s2); // === false, 属性"p"可写
      
      var s3 = Object.seal({ get p() { return 0; } });
      Object.isFrozen(s3); // === true ,访问器属性不考虑可写不可写,只考虑是否可配置
      
    1. Object.keys(): 返回一个包含所有给定对象自身可枚举属性名称的数组。

      // simple array
      var arr = ['a', 'b', 'c'];
      console.log(Object.keys(arr)); // console: ['0', '1', '2']
      
      // array like object
      var obj = { 0: 'a', 1: 'b', 2: 'c' };
      console.log(Object.keys(obj)); // console: ['0', '1', '2']
      
      // array like object with random key ordering
      var anObj = { 100: 'a', 2: 'b', 7: 'c' };
      console.log(Object.keys(anObj)); // console: ['2', '7', '100']
      
      // getFoo is a property which isn't enumerable
      var myObj = Object.create({}, {
        getFoo: {
          value: function () { return this.foo; }
        } 
      });
      myObj.foo = 1;
      console.log(Object.keys(myObj)); // console: ['foo']
      
    1. Object.preventExtensions(): 防止对象的任何扩展。

      // Object.preventExtensions将原对象变的不可扩展,并且返回原对象.
      var obj = {};
      var obj2 = Object.preventExtensions(obj);
      obj === obj2;  // true
       
      // 字面量方式定义的对象默认是可扩展的.
      var empty = {};
      Object.isExtensible(empty) //=== true
       
      // ...但可以改变.
      Object.preventExtensions(empty);
      Object.isExtensible(empty) //=== false
       
      // 使用Object.defineProperty方法为一个不可扩展的对象添加新属性会抛出异常.
      var nonExtensible = { removable: true };
      Object.preventExtensions(nonExtensible);
      Object.defineProperty(nonExtensible, "new", { value: 8675309 }); // 抛出TypeError异常
       
      // 在严格模式中,为一个不可扩展对象的新属性赋值会抛出TypeError异常.
      function fail()
      {
        "use strict";
        nonExtensible.newProperty = "FAIL"; // throws a TypeError
      }
      fail();
       
      // 一个不可扩展对象的原型是不可更改的,__proto__是个非标准魔法属性,可以更改一个对象的原型.
      var fixed = Object.preventExtensions({});
      fixed.__proto__ = { oh: "hai" }; // 抛出TypeError异常
      
    1. Object.seal(): 防止其他代码删除对象的属性。

      const object1 = {
        property1: 42
      };
      
      Object.seal(object1);
      object1.property1 = 33;
      console.log(object1.property1);
      // expected output: 33
      
      delete object1.property1; // cannot delete when sealed
      console.log(object1.property1);
      // expected output: 33
      

      注意:

      1. 阻止添加新属性并将所有现有属性标记为不可配置
      2. 当前属性的值只要可写就可以改变
    1. Object.setPrototypeOf(): 设置对象的原型(即内部 [[Prototype]] 属性)。

    2. Object.values(): 返回给定对象自身可枚举值的数组。

      var obj = { foo: 'bar', baz: 42 };
      console.log(Object.values(obj)); // ['bar', 42]
      
      // array like object
      var obj = { 0: 'a', 1: 'b', 2: 'c' };
      console.log(Object.values(obj)); // ['a', 'b', 'c']
      
      // array like object with random key ordering
      // when we use numeric keys, the value returned in a numerical order according to the keys
      var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
      console.log(Object.values(an_obj)); // ['b', 'c', 'a']
      
      // getFoo is property which isn't enumerable
      var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
      my_obj.foo = 'bar';
      console.log(Object.values(my_obj)); // ['bar']
      
      // non-object argument will be coerced to an object
      console.log(Object.values('foo')); // ['f', 'o', 'o']
      

    8. RegExp

    1. 创建正则表达式

    第一种方式:正则表达式字面量

    const regex = /ab+c/;
    const regex = /^[a-zA-Z]+[0-9]*\W?_$/gi;
    

    第二种方式:调用RegExp构造函数

    let regex = new RegExp("ab+c");
    
    let regex = new RegExp(/^[a-zA-Z]+[0-9]*\W?_$/, "gi");
    
    let regex = new RegExp("^[a-zA-Z]+[0-9]*\\W?_$", "gi");
    

    2. 特殊字符含义

    字符 含义
    \ 转义字符
    ^ 匹配输入的开始
    $ 匹配输入的结束
    . (小数点)匹配除换行符之外的任何单个字符。
    x|y 匹配‘x’或者‘y’。
    [xyz] 一个字符集合。匹配方括号中的任意字符,包括转义序列。你可以使用破折号(-)来指定一个字符范围。对于点(.)和星号(*)这样的特殊符号在一个字符集中没有特殊的意义。他们不必进行转义,不过转义也是起作用的
    [^xyz] 一个反向字符集。也就是说, 它匹配任何没有包含在方括号中的字符。你可以使用破折号(-)来指定一个字符范围。任何普通字符在这里都是起作用的。
    * 匹配前一个表达式0次或多次。等价于 {0,}。
    + 匹配前面一个表达式1次或者多次。等价于 {1,}。
    ? 匹配前面一个表达式0次或者1次。等价于 {0,1}。
    如果紧跟在任何量词 *、 +、? 或 {} 的后面,将会使量词变为非贪婪的(匹配尽量少的字符),和缺省使用的贪婪模式(匹配尽可能多的字符)正好相反。
    {n} n是一个正整数,匹配了前面一个字符刚好发生了n次。
    {n,m} n 和 m 都是整数。匹配前面的字符至少n次,最多m次。如果 n 或者 m 的值是0, 这个值被忽略。
    (x) 匹配 'x' 并且记住匹配项。括号被称为 捕获括号
    (?:) 匹配 'x' 但是不记住匹配项。这种叫作非捕获括号
    x(?=y) 匹配'x'仅仅当'x'后面跟着'y'.这种叫做先行断言。
    (?<=y)x 匹配'x'仅仅当'x'前面是'y'.这种叫做后行断言。
    x(?!y) 匹配'x'仅仅当'x'后面不跟着'y',这个叫做正向否定查找。
    \b 匹配一个词的边界
    \B 匹配一个非单词边界
    \d 匹配数字
    \D 匹配一个非数字字符
    \s 匹配一个空白字符,包括空格、制表符、换页符和换行符。
    \S 匹配一个非空白字符。
    \w 匹配一个单字字符(字母、数字或者下划线)。等价于[A-Za-z0-9_]
    \W 匹配一个非单字字符。
    \n 换行符
    \r 回车符
    \t 水平制表符
    \u{hhhh} (仅当设置了u标志时) 使用Unicode值hhhh匹配字符 (十六进制数字).

    3. 使用

    方法 描述
    exec 一个在字符串中执行查找匹配的RegExp方法,它返回一个数组(未匹配到则返回null)。
    test 一个在字符串中测试是否匹配的RegExp方法,它返回true或false。
    match 一个在字符串中执行查找匹配的String方法,它返回一个数组或者在未匹配到时返回null。
    search 一个在字符串中测试匹配的String方法,它返回匹配到的位置索引,或者在失败时返回-1。
    replace 一个在字符串中执行查找匹配的String方法,并且使用替换字符串替换掉匹配到的子字符串。
    split 一个使用正则表达式或者一个固定字符串分隔一个字符串,并将分隔后的子字符串存储到数组中的String方法。

    4. 标志符(模式修正符)

    标志 描述
    g 全局搜索
    i 不区分大小写搜索
    m 多行搜索
    y 执行"粘性"搜索,匹配从目标字符串的当前位置开始,可以使用y标志。

    相关文章

      网友评论

          本文标题:(10)内置对象-2

          本文链接:https://www.haomeiwen.com/subject/cadqtctx.html