内置对象（2）
我们平时忙于开发，很少有时间能够将文档看一遍。这样在很多时候，我们本可以一个原生方法能够实现的程序，却累的跟狗一样，写出来的程序还不定好使。为了减少重复造轮子的时间，将MDN的API结合自己的理解，归纳整理了下面的文档。MDN文档-JavaScript内置对象
7. Object
let obj = new Object;
Object 构造函数创建一个对象包装器。
Object构造函数的属性：
- Object.length: 值为1
- Object.prototype: 为所有的Object类型的对象添加属性。
Object构造函数的方法：
-
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 }
-
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 };
-
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时也会直接报错
-
Object.defineProperties(): 给对象添加多个属性并分别指定它们的配置。
var person = {}; Object.defineProperties(person, { name: { value: 'modeest' }, age: { value: 18 } })
-
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"]]
-
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注意：
- 一个被冻结的对象再也不能被修改；
- 冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。
- 冻结一个对象后该对象的原型也不能被修改。
freeze()返回和传入的参数相同的对象。
-
Object.getOwnPropertyDescriptor(): 返回对象指定的属性配置。
Object.getOwnPropeertyDescriptor(person, 'name');
-
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"]
Object.getOwnPropertySymbols(): 返回一个数组，它包含了指定对象自身所有的符号属性。
-
Object.getPrototypeOf(): 返回指定对象的原型对象。
const prototype1 = {}; const object1 = Object.create(prototype1); console.log(Object.getPrototypeOf(object1) === prototype1); // expected output: true
-
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
-
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
-
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
-
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 ，访问器属性不考虑可写不可写,只考虑是否可配置
-
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']
-
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异常
-
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注意：
- 阻止添加新属性并将所有现有属性标记为不可配置
- 当前属性的值只要可写就可以改变
Object.setPrototypeOf(): 设置对象的原型（即内部
[[Prototype]]属性）。-
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标志。 |