// 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
// 最简单的方法来生成一个密封对象,当然是使用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 ，访问器属性不考虑可写不可写,只考虑是否可配置
**（15）Object.keys()**
`Object.keys()` 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和正常循环遍历该对象时返回的顺序一致 。
**语法**：
Object.keys(obj)
**参数**：
* `obj` 要返回其枚举自身属性的对象。
**返回值**：
一个表示给定对象的所有可枚举属性的字符串数组。
**示例**：
// 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’]
**（16）Object.preventExtensions()**
`Object.preventExtensions()` 方法让一个对象变的不可扩展，也就是永远不能再添加新的属性。
**语法**：
Object.preventExtensions(obj)
**参数**：
* `obj` 将要变得不可扩展的对象。
**返回值**：
已经不可扩展的对象。
**示例**：
// 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();
**（17）Object.seal()**
Object.seal()方法封闭一个对象，阻止添加新属性并将所有现有属性标记为不可配置。当前属性的值只要原来是可写的就可以改变。
**语法**：
Object.seal(obj)
**参数**：
* `obj` 将要被密封的对象。
**返回值**：
被密封的对象。
**示例**：
var obj = {
prop: function() {},
foo: ‘bar’
};
// 可以添加新的属性
// 可以更改或删除现有的属性
obj.foo = ‘baz’;
常用的JavaScript设计模式
-
单体模式
-
工厂模式
-
例模式
函数
-
函数的定义
-
局部变量和全局变量
-
返回值
-
匿名函数
-
自运行函数
-
闭包
开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】
原创文章，作者：kepupublish，如若转载，请注明出处：https://blog.ytso.com/171511.html