JavaScript Object 构造函数方法

console.log(‘Is rect an instance of Shape?’,

rect instanceof Shape); // true

rect.move(1, 1); // Outputs, ‘Shape moved.’

（3）Object.defineProperty()

Object.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回此对象。

语法：

Object.defineProperty(obj, prop, descriptor)

参数：

• obj 要定义属性的对象。

• prop 要定义或修改的属性的名称或 Symbol。

• descriptor 要定义或修改的属性描述符。

返回值：

被传递给函数的对象。

示例：创建属性

如果对象中不存在指定的属性，Object.defineProperty() 会创建这个属性。当描述符中省略某些字段时，这些字段将使用它们的默认值。

var o = {}; // 创建一个新对象

// 在对象中添加一个属性与数据描述符的示例

Object.defineProperty(o, “a”, {

value : 37,

writable : true,

enumerable : true,

configurable : true

});

// 对象 o 拥有了属性 a，值为 37

// 在对象中添加一个设置了存取描述符属性的示例

var bValue = 38;

Object.defineProperty(o, “b”, {

// 使用了方法名称缩写（ES2015 特性）

// 下面两个缩写等价于：

// get : function() { return bValue; },

// set : function(newValue) { bValue = newValue; },

get() { return bValue; },

set(newValue) { bValue = newValue; },

enumerable : true,

configurable : true

});

o.b; // 38

// 对象 o 拥有了属性 b，值为 38

// 现在，除非重新定义 o.b，o.b 的值总是与 bValue 相同

// 数据描述符和存取描述符不能混合使用

Object.defineProperty(o, “conflict”, {

value: 0x9f91102,

get() { return 0xdeadbeef; }

});

// 抛出错误 TypeError: value appears only in data descriptors, get appears only in accessor descriptors

（4）Object.defineProperties()

Object.defineProperties() 方法直接在一个对象上定义新的属性或修改现有属性，并返回该对象。

语法：

Object.defineProperties(obj, props)

参数：

• obj 在其上定义或修改属性的对象。

• props 要定义其可枚举属性或修改的属性描述符的对象。对象中存在的属性描述符主要有两种：数据描述符和访问器描述符。

返回值：

传递给函数的对象。

示例：

Object.defineProperties 本质上定义了obj 对象上props的可枚举属性相对应的所有属性。

var obj = {};

Object.defineProperties(obj, {

‘property1’: {

value: true,

writable: true

},

‘property2’: {

value: ‘Hello’,

writable: false

}

// etc. etc.

});

（5）Object.entries()

Object.entries() 方法返回一个给定对象自身可枚举属性的键值对数组，其排列与使用 for...in 循环遍历该对象时返回的顺序一致（区别在于 for-in 循环还会枚举原型链中的属性）。

语法：

Object.entries(obj)

参数：

• obj 可以返回其可枚举属性的键值对的对象。

返回值：

给定对象自身可枚举属性的键值对数组。

示例：

const obj = { foo: ‘bar’, baz: 42 };

console.log(Object.entries(obj)); // [ [‘foo’, ‘bar’], [‘baz’, 42] ]

// array like object

const obj = { 0: ‘a’, 1: ‘b’, 2: ‘c’ };

console.log(Object.entries(obj)); // [ [‘0’, ‘a’], [‘1’, ‘b’], [‘2’, ‘c’] ]

// array like object with random key ordering

const anObj = { 100: ‘a’, 2: ‘b’, 7: ‘c’ };

console.log(Object.entries(anObj)); // [ [‘2’, ‘b’], [‘7’, ‘c’], [‘100’, ‘a’] ]

// getFoo is property which isn’t enumerable

const myObj = Object.create({}, { getFoo: { value() { return this.foo; } } });

myObj.foo = ‘bar’;

console.log(Object.entries(myObj)); // [ [‘foo’, ‘bar’] ]

// non-object argument will be coerced to an object

console.log(Object.entries(‘foo’)); // [ [‘0’, ‘f’], [‘1’, ‘o’], [‘2’, ‘o’] ]

// iterate through key-value gracefully

const obj = { a: 5, b: 7, c: 9 };

for (const [key, value] of Object.entries(obj)) {

console.log(${key} ${value}); // “a 5”, “b 7”, “c 9”

}

// Or, using array extras

Object.entries(obj).forEach(([key, value]) => {

console.log(${key} ${value}); // “a 5”, “b 7”, “c 9”

});

（6）Object.freeze()

Object.freeze() 方法可以冻结一个对象。一个被冻结的对象再也不能被修改；freeze() 返回和传入的参数相同的对象。

语法：

Object.freeze(obj)

参数：

• obj 要被冻结的对象。

返回值：

被冻结的对象。

示例：冻结对象

var obj = {

prop: function() {},

foo: ‘bar’

};

// 新的属性会被添加, 已存在的属性可能

// 会被修改或移除

obj.foo = ‘baz’;

obj.lumpy = ‘woof’;

delete obj.prop;

// 作为参数传递的对象与返回的对象都被冻结

// 所以不必保存返回的对象（因为两个对象全等）

var o = Object.freeze(obj);

o === obj; // true

Object.isFrozen(obj); // === true

// 现在任何改变都会失效

obj.foo = ‘quux’; // 静默地不做任何事

// 静默地不添加此属性

obj.quaxxor = ‘the friendly duck’;

// 在严格模式，如此行为将抛出 TypeErrors

function fail(){

‘use strict’;

obj.foo = ‘sparky’; // throws a TypeError

delete obj.quaxxor; // 返回true，因为quaxxor属性从来未被添加

obj.sparky = ‘arf’; // throws a TypeError

}

fail();

// 试图通过 Object.defineProperty 更改属性

// 下面两个语句都会抛出 TypeError.

Object.defineProperty(obj, ‘ohai’, { value: 17 });

Object.defineProperty(obj, ‘foo’, { value: ‘eit’ });

// 也不能更改原型

// 下面两个语句都会抛出 TypeError.

Object.setPrototypeOf(obj, { x: 20 })

obj.proto = { x: 20 }

（7）Object.getOwnPropertyDescriptor()

Object.getOwnPropertyDescriptor() 方法返回指定对象上一个自有属性对应的属性描述符。

语法：

Object.getOwnPropertyDescriptor(obj, prop)

参数：

• obj 需要查找的目标对象。

• prop 目标对象内属性名称。

返回值：

如果指定的属性存在于对象上，则返回其属性描述符对象（property descriptor），否则返回 undefined。

示例：

var o, d;

o = { get foo() { return 17; } };

d = Object.getOwnPropertyDescriptor(o, “foo”);

// d {

// configurable: true,

// enumerable: true,

// get: /the getter function/,

// set: undefined

// }

o = { bar: 42 };

d = Object.getOwnPropertyDescriptor(o, “bar”);

// d {

// configurable: true,

// enumerable: true,

// value: 42,

// writable: true

// }

o = {};

Object.defineProperty(o, “baz”, {

value: 8675309,

writable: false,

enumerable: false

});

d = Object.getOwnPropertyDescriptor(o, “baz”);

// d {

// value: 8675309,

// writable: false,

// enumerable: false,

// configurable: false

// }

（8）Object.getOwnPropertyNames()

Object.getOwnPropertyNames() 方法返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。

语法：

Object.getOwnPropertyNames(obj)

参数：

• obj 一个对象，其自身的可枚举和不可枚举属性的名称被返回。

返回值：

在给定对象上找到的自身属性对应的字符串数组。

示例：

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”]

// 使用Array.forEach输出属性名和属性值

Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) {

console.log(val + " -> " + obj[val]);

});

// 输出

// 0 -> a

// 1 -> b

// 2 -> c

//不可枚举属性

var my_obj = Object.create({}, {

getFoo: {

value: function() { return this.foo; },

enumerable: false

}

});

my_obj.foo = 1;

console.log(Object.getOwnPropertyNames(my_obj).sort()); // [“foo”, “getFoo”]

（9）Object.getOwnPropertySymbols()

Object.getOwnPropertySymbols() 方法返回一个给定对象自身的所有 Symbol 属性的数组。

语法：

Object.getOwnPropertySymbols(obj)

参数：

• obj 要返回 Symbol 属性的对象。

返回值：

在给定对象自身上找到的所有 Symbol 属性的数组。

示例：

var obj = {};

var a = Symbol(“a”);

var b = Symbol.for(“b”);

obj[a] = “localSymbol”;

obj[b] = “globalSymbol”;

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // 2

console.log(objectSymbols) // [Symbol(a), Symbol(b)]

console.log(objectSymbols[0]) // Symbol(a)

（10）Object.getPrototypeOf()

Object.getPrototypeOf() 方法返回指定对象的原型。

语法：

Object.getPrototypeOf(object)

参数：

• obj 要返回其原型的对象。

返回值：

给定对象的原型。如果没有继承属性，则返回 null。

示例：

var proto = {};

var obj = Object.create(proto);

Object.getPrototypeOf(obj) === proto; // true

var reg = /a/;

Object.getPrototypeOf(reg) === RegExp.prototype; // true

（11）Object.is()

Object.is() 方法判断两个值是否为同一个值。

语法：

Object.is(value1, value2);

参数：

• value1 被比较的第一个值。

• value2 被比较的第二个值。

返回值：

一个 Boolean 类型标示两个参数是否是同一个值。

示例：

if (!Object.is) {

Object.is = function(x, y) {

// SameValue algorithm

if (x === y) { // Steps 1-5, 7-10

// Steps 6.b-6.e: +0 != -0

return x !== 0 || 1 / x === 1 / y;

} else {

// Step 6.a: NaN == NaN

return x !== x && y !== y;

}

};

}

（12）Object.isExtensible()

Object.isExtensible() 方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。

语法：

Object.isExtensible(obj)

参数：

• obj 需要检测的对象

返回值：

表示给定对象是否可扩展的一个Boolean。

示例：

// 新对象默认是可扩展的.

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

（13）Object.isFrozen()

Object.isFrozen()方法判断一个对象是否被冻结。

语法：

Object.isFrozen(obj)

参数：

• obj 被检测的对象。

返回值：

表示给定对象是否被冻结的Boolean。

示例：

// 一个对象默认是可扩展的,所以它也是非冻结的.

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

（14）Object.isSealed()

Object.isSealed() 方法判断一个对象是否被密封。

语法：

Object.isSealed(obj)

参数：

• obj 要被检查的对象。

返回值：

表示给定对象是否被密封的一个Boolean 。

示例：

// 新建的对象默认不是密封的.

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); // === false

Object.isSealed(hasProp.fee); // === true

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
y = {};

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); // === false

Object.isSealed(hasProp.fee); // === true

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-TOa0PCVn-1715463901905)]

[外链图片转存中…(img-glk7Hs0v-1715463901905)]

[外链图片转存中…(img-BcbVD1cR-1715463901905)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！