关于JavaScript的Object所有方法

最新推荐文章于 2024-04-29 17:01:02 发布
最新推荐文章于 2024-04-29 17:01:02 发布
阅读量3.6k 收藏 37
点赞数 4
分类专栏： Javascript 文章标签： javascript 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45142260/article/details/126012642
版权

1. Object.assign()–复制修改对象

Object.assign() 方法将所有可枚举（Object.propertyIsEnumerable() 返回 true）和自有（Object.hasOwnProperty() 返回 true）属性从一个或多个源对象复制到目标对象，返回修改后的对象

尝试一下

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };

const returnedTarget = Object.assign(target, source);

console.log(target);
// { a: 1, b: 4, c: 5 }

console.log(returnedTarget);
//  { a: 1, b: 4, c: 5 }

语法

Object.assign(target, ...sources)

参数

  • target 目标对象，接收源对象属性的对象，也是修改后的返回值。
  • sources 源对象，包含将被合并的属性。

返回值
目标对象

2. Object.create()–创建新对象

Object.create() 方法用于创建一个新对象，使用现有的对象来作为新创建对象的原型（prototype）

示例

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';
me.isHuman = true; 
me.printIntroduction();
// "My name is Matthew. Am I human? true"

语法

Object.create(proto)
Object.create(proto, propertiesObject)

参数

  • proto 新创建对象的原型对象。
  • propertiesObject （可选）如果该参数被指定且不为 undefined，则该传入对象的自有可枚举属性（即其自身定义的属性，而不是其原型链上的枚举属性）将为新创建的对象添加指定的属性值和对应的属性描述符。这些属性对应于 Object.defineProperties() 的第二个参数。

返回值
一个新对象，带着指定的原型对象及其属性。

3. Object.defineProperty()–vue数据响应式原理

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

const object1 = {};

Object.defineProperty(object1, 'property1', {
  value: 42,
  writable: false // 不可编辑
});

object1.property1 = 77;
// error

console.log(object1.property1);
//  42

语法

Object.defineProperty(obj, prop, descriptor)

参数

  • obj 要定义属性的对象。
  • prop 要定义或修改的属性的名称或 Symbol 。
  • descriptor 要定义或修改的属性描述符。

返回值
被传递给函数的对象。

更多>>

4. Object.defineProperties()–类似defineProperty

更多>>

5. Object.entries()–对象转map

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

const object1 = {
  a: 'somestring',
  b: 42
};

for (const [key, value] of Object.entries(object1)) {
  console.log(`${key}: ${value}`);
}

// "a: somestring"
// "b: 42"

语法

Object.entries(obj)

参数

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

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

描述
Object.entries()返回一个数组，其元素是与直接在object上找到的可枚举属性键值对相对应的数组。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。

6. Object.freeze()–冻结对象

Object.freeze() 方法可以冻结一个对象。一个被冻结的对象再也不能被修改；冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。此外，冻结一个对象后该对象的原型也不能被修改。freeze() 返回和传入的参数相同的对象。

const obj = {
  prop: 42
};

Object.freeze(obj);

obj.prop = 33;
// error

console.log(obj.prop);
//  42

语法

Object.freeze(obj)

返回值
被冻结的对象。
描述

  • 被冻结对象自身的所有属性都不可能以任何方式被修改。任何修改尝试都会失败，无论是静默地还是通过抛出TypeError异常（最常见但不仅限于strict mode）。
  • 数据属性的值不可更改，访问器属性（有 getter 和 setter）也同样（但由于是函数调用，给人的错觉是还是可以修改这个属性）。如果一个属性的值是个对象，则这个对象中的属性是可以修改的，除非它也是个冻结对象。数组作为一种对象，被冻结，其元素不能被修改。没有数组元素可以被添加或移除。
  • 这个方法返回传递的对象，而不是创建一个被冻结的副本。

示例

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.fromEntries()-- 键值对列表（如map）转对象

Object.fromEntries() 方法把键值对列表转换为一个对象。

const entries = new Map([
  ['foo', 'bar'],
  ['baz', 42]
]);

const obj = Object.fromEntries(entries);

console.log(obj);
// { foo: "bar", baz: 42 }

语法

Object.fromEntries(iterable);

参数

  • iterable 类似 Array 、 Map 或者其它实现了可迭代协议的可迭代对象。

描述
Object.fromEntries() 方法接收一个键值对的列表参数，并返回一个带有这些键值对的新对象。这个迭代参数应该是一个能够实现@@iterator方法的的对象，返回一个迭代器对象。它生成一个具有两个元素的类数组的对象，第一个元素是将用作属性键的值，第二个元素是与该属性键关联的值。

Object.fromEntries() 执行与 Object.entries 互逆的操作。

8. Object.getOwnPropertyDescriptor()–返回指定属性的属性描述符

Object.getOwnPropertyDescriptor() 方法返回指定对象上一个自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）

const object1 = {
  property1: 42
};

const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');

console.log(descriptor1.configurable);
//  true

console.log(descriptor1.value);
//  42

语法

Object.getOwnPropertyDescriptor(obj, prop)

参数

  • obj 需要查找的目标对象
  • prop 目标对象内属性名称

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

9. Object.getOwnPropertyDescriptors()–返回对象所有属性描述符

Object.getOwnPropertyDescriptors() 方法用来获取一个对象的所有自身属性的描述符。
语法

Object.getOwnPropertyDescriptors(obj)

参数

  • obj 任意对象

返回值
所指定对象的所有自身属性的描述符，如果没有任何自身属性，则返回空对象。

10. Object.getOwnPropertyNames()–返回所有属性名

Object.getOwnPropertyNames() 返回一个数组，该数组对元素是 obj自身拥有的枚举或不可枚举属性名称字符串。 数组中枚举属性的顺序与通过 for…in 循环（或 Object.keys）迭代该对象属性时一致。数组中不可枚举属性的顺序未定义。

示例

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

11. Object.getOwnPropertySymbols()–返回对象所有Symbol 属性

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)

12. Object.getPrototypeOf()–返回对象的原型

Object.getPrototypeOf() 方法返回指定对象的原型（内部[[Prototype]]属性的值）。
语法

Object.getPrototypeOf(object)

参数

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

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

const prototype1 = {};
const object1 = Object.create(prototype1);

console.log(Object.getPrototypeOf(object1) === prototype1);
//  true

示例

var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true

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

13. Object.hasOwn()–检查对象中是否含有指定属性

如果指定的对象具有指定的属性，则 Object.hasOwn() 方法返回 true。如果属性被继承或不存在，则该方法返回 false。

const object1 = {
  prop: 'exists'
};

console.log(Object.hasOwn(object1, 'prop'));
// true

console.log(Object.hasOwn(object1, 'toString'));
// false

console.log(Object.hasOwn(object1, 'undeclaredPropertyValue'));
//  false

语法

  • instance 指定对象
  • prop 指定的属性值

返回值
如果指定对象直接定义了指定属性，则为 true。否则为false

14. Object.prototype.hasOwnProperty()–同Object.hasOwn()

更多

15. Object.is()–判断两个值是否为同一个值

语法

Object.is(value1, value2);

参数

  • value1 被比较的第一个值。
  • value2 被比较的第二个值。

返回值
一个布尔值，表示两个参数是否是同一个值。
描述

  • Object.is() 方法判断两个值是否为同一个值，如果满足以下任意条件则两个值相等：
    1 都是 undefined
    2 都是 null
    3 都是 true 或都是 false
    4 都是相同长度、相同字符、按相同顺序排列的字符串
    5 都是相同对象（意味着都是同一个对象的值引用）
    6 都是数字且：
    6.1 都是 +0
    6.2 都是 -0
    6.3 都是 NaN
    6.4 都是同一个值，非零且都不是 NaN
  • Object.is() 与 == 不同。== 运算符在判断相等前对两边的变量（如果它们不是同一类型）进行强制转换（这种行为将 “” ==
    false 判断为 true），而 Object.is 不会强制转换两边的值。
  • Object.is() 与 === 也不相同。差别是它们对待有符号的零和 NaN 不同，例如，=== 运算符（也包括 == 运算符）将数字
    -0 和 +0 视为相等，而将 Number.NaN 与 NaN 视为不相等。

示例

//  1
Object.is(25, 25);                // true
Object.is('foo', 'foo');          // true
Object.is('foo', 'bar');          // false
Object.is(null, null);            // true
Object.is(undefined, undefined);  // true
Object.is(window, window);        // true
Object.is([], []);                // false
var foo = { a: 1 };
var bar = { a: 1 };
Object.is(foo, foo);              // true
Object.is(foo, bar);              // false

//  2
Object.is(0, -0);                 // false
Object.is(+0, -0);                // false
Object.is(-0, -0);                // true
Object.is(0n, -0n);               // true

// 3
Object.is(NaN, 0/0);              // true
Object.is(NaN, Number.NaN)        // true

16. Object.isExtensible()–判断对象是否可扩展

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

语法

Object.isExtensible(obj)

参数

  • obj 需要检测的对象

返回值
表示给定对象是否可扩展的一个Boolean 。
描述
默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 __proto__Deprecated 属性可以被更改。Object.preventExtensions，Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展（non-extensible）。
示例

// 新对象默认是可扩展的。
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

17. Object.isFrozen()–判断对象是否被冻结

语法

Object.isFrozen(obj)

参数

  • obj 被检测的对象。

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

描述
一个对象是冻结的是指它不可扩展，所有属性都是不可配置的，且所有数据属性（即没有 getter 或 setter 组件的访问器的属性）都是不可写的。

示例

// 一个对象默认是可扩展的，所以它也是非冻结的。
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

18. Object.prototype.isPrototypeOf()–测试对象是否存在于另一个原型链上

isPrototypeOf() 方法用于测试一个对象是否存在于另一个对象的原型链上。

语法

prototypeObj.isPrototypeOf(object)

参数

object 在该对象的原型链上搜寻

返回值
Boolean，表示调用对象是否在另一个对象的原型链上。

描述
isPrototypeOf() 方法允许你检查一个对象是否存在于另一个对象的原型链上。

示例

function Foo() {}
function Bar() {}
function Baz() {}

Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);

var baz = new Baz();

console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true

19. Object.isSealed()–判断对象是否被密封

语法

Object.isSealed(obj)

参数

  • obj 要被检查的对象。

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

描述
如果这个对象是密封的，则返回 true，否则返回 false。密封对象是指那些不可 扩展 的，且所有自身属性都不可配置且因此不可删除（但不一定是不可写）的对象。

示例

// 新建的对象默认不是密封的。
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 ，访问器属性不考虑可写不可写，只考虑是否可配置

20. Object.keys()–返回对象所有属性名

Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和正常循环遍历该对象时返回的顺序一致。

语法

Object.keys(obj)

参数

  • obj 要返回其枚举自身属性的对象。

返回值
一个表示给定对象的所有可枚举属性的字符串数组。

描述
Object.keys 返回一个所有元素为字符串的数组，其元素来自于从给定的 object 上面可直接枚举的属性。这些属性的顺序与手动遍历该对象属性时的一致。

示例

var arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']

var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.keys(obj)); // console: ['0', '1', '2']

var anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.keys(anObj)); // console: ['2', '7', '100']

var myObj = Object.create({}, {
  getFoo: {
    value: function () { return this.foo; }
  }
});
myObj.foo = 1;
console.log(Object.keys(myObj)); // console: ['foo']

21. Object.preventExtensions()–使对象不可扩展

Object.preventExtensions()方法让一个对象变的不可扩展，也就是永远不能再添加新的属性。

const object1 = {};

Object.preventExtensions(object1);

try {
  Object.defineProperty(object1, 'property1', {
    value: 42
  });
} catch (e) {
  console.log(e);
  // expected output: TypeError: Cannot define property property1, object is not extensible
}

语法

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();

22. Object.prototype.propertyIsEnumerable()–判断属性是否可枚举

propertyIsEnumerable() 方法返回一个布尔值，表示指定的属性是否可枚举。

const object1 = {};
const array1 = [];
object1.property1 = 42;
array1[0] = 42;

console.log(object1.propertyIsEnumerable('property1'));
//  true

console.log(array1.propertyIsEnumerable(0));
//  true

console.log(array1.propertyIsEnumerable('length'));
//  false

语法

obj.propertyIsEnumerable(prop)

参数

  • prop 需要测试的属性名。

返回值
用来表示指定的属性名是否可枚举的布尔值。

描述
每个对象都有一个 propertyIsEnumerable 方法。此方法可以确定对象中指定的属性是否可以被 for…in 循环枚举，但是通过原型链继承的属性除外。如果对象没有指定的属性，则此方法返回 false。

示例

var o = {};
var a = [];
o.prop = 'is enumerable';
a[0] = 'is enumerable';

o.propertyIsEnumerable('prop'); // 返回 true
a.propertyIsEnumerable(0);      // 返回 true

23. Object.seal()–封闭对象

Object.seal()方法封闭一个对象，阻止添加新属性并将所有现有属性标记为不可配置。当前属性的值只要原来是可写的就可以改变。

const object1 = {
  property1: 42
};

Object.seal(object1);
object1.property1 = 33;
console.log(object1.property1);
//33

delete object1.property1; // cannot delete when sealed
console.log(object1.property1);
//  33

语法

Object.seal(obj)

参数

  • obj 将要被密封的对象。

返回值
被密封的对象。

描述
通常，一个对象是可扩展的（可以添加新的属性）。密封一个对象会让这个对象变的不能添加新属性，且所有已有属性会变的不可配置。属性不可配置的效果就是属性变的不可删除，以及一个数据属性不能被重新定义成为访问器属性，或者反之。但属性的值仍然可以修改。尝试删除一个密封对象的属性或者将某个密封对象的属性从数据属性转换成访问器属性，结果会静默失败或抛出TypeError（在严格模式 中最常见的，但不唯一）。

不会影响从原型链上继承的属性。但 proto ( Deprecated ) 属性的值也会不能修改。

返回被密封对象的引用。

24. Object.setPrototypeOf()–指定对象的原型

Object.setPrototypeOf() 方法设置一个指定的对象的原型 ( 即，内部 [[Prototype]] 属性）到另一个对象或 null。

语法

Object.setPrototypeOf(obj, prototype)

参数

  • obj 要设置其原型的对象。
  • prototype 该对象的新原型 (一个对象 或 null).

描述
如果对象的 [[Prototype]] 被修改成不可扩展 (通过 Object.isExtensible()查看)，就会抛出 TypeError 异常。如果 prototype 参数不是一个对象或者 null (例如，数字，字符串，boolean，或者 undefined)，则什么都不做。否则，该方法将 obj 的 [[Prototype]] 修改为新的值。

Object.setPrototypeOf() 是 ECMAScript 6 最新草案中的方法，相对于 Object.prototype.proto (en-US)，它被认为是修改对象原型更合适的方法

25. Object.prototype.toLocaleString()–返回该对象的字符串表示

toLocaleString() 方法返回一个该对象的字符串表示。此方法被用于派生对象为了特定语言环境的目的（locale-specific purposes）而重载使用。

语法

obj.toLocaleString();

返回值
表示对象的字符串。

描述
Object toLocaleString 返回调用 toString() 的结果。

该函数提供给对象一个通用的toLocaleString 方法，即使不是全部都可以使用它。

26. Object.prototype.toString()–返回值表示该对象的字符串

function Dog(name) {
  this.name = name;
}

const dog1 = new Dog('Gabby');

Dog.prototype.toString = function dogToString() {
  return `${this.name}`;
};

console.log(dog1.toString());
// "Gabby"

描述
每个对象都有一个 toString() 方法，当该对象被表示为一个文本值时，或者一个对象以预期的字符串方式引用时自动调用。默认情况下，toString() 方法被每个 Object 对象继承。如果此方法在自定义对象中未被覆盖，toString() 返回 “[object type]”，其中 type 是对象的类型。以下代码说明了这一点：

var o = new Object();
o.toString(); // 返回 [object Object]

27. Object.prototype.valueOf()–返回指定对象的原始值

语法

object.valueOf()

描述

JavaScript 调用 valueOf 方法将对象转换为原始值。你很少需要自己调用 valueOf 方法；当遇到要预期的原始值的对象时，JavaScript 会自动调用它。

默认情况下，valueOf 方法由 Object 后面的每个对象继承。 每个内置的核心对象都会覆盖此方法以返回适当的值。如果对象没有原始值，则 valueOf 将返回对象本身。

JavaScript 的许多内置对象都重写了该函数，以实现更适合自身的功能需要。因此，不同类型对象的 valueOf() 方法的返回值和返回值类型均可能不同。

对象返回值
Array返回值数组对象本身
Boolean布尔值
Date存储的时间从1970年1月1日午夜开始计的毫秒数UTC
Function函数本身
Number数字值
Object对象本身。这是默认值
string字符串值
Math和Error对象没有valueOf方法。

你可以在自己的代码中使用 valueOf 将内置对象转换为原始值。创建自定义对象时，可以覆盖 Object.prototype.valueOf() 来调用自定义方法，而不是默认 Object 方法。

28. Object.values()–返回对象所有属性值

Object.values()方法返回一个给定对象自身的所有可枚举属性值的数组，值的顺序与使用for…in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。

语法

Object.values(obj)

参数

  • obj 被返回可枚举属性值的对象。

返回值
一个包含对象自身的所有可枚举属性值的数组。

描述
Object.values()返回一个数组，其元素是在对象上找到的可枚举属性值。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。

示例

var obj = { foo: 'bar', baz: 42 };
console.log(Object.values(obj)); // ['bar', 42]

var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.values(obj)); // ['a', 'b', 'c']

var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.values(an_obj)); // ['b', 'c', 'a']

var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
my_obj.foo = 'bar';
console.log(Object.values(my_obj)); // ['bar']

console.log(Object.values('foo')); // ['f', 'o', 'o']

参考MDN

键盘上行走的猿
关注
  • 4
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ES6 Object方法扩展的应用实例分析
10-16
主要介绍了ES6 Object方法扩展的应用,结合实例形式总结分析了ES6针对对象方法的扩展与优化,需要的朋友可以参考下
Object的所有方法
lsw333521的博客
12-06 135
java中Object类中的所有方法简介
一文看懂Object类的12个方法
zndxlwl163的博客
10-31 693
昨天博主整理发布了在秋招面试中常被问到的20道Java基础题目，有不少小伙伴私信问我答案，其实这些问题如果自己去网上搜的话，也可以搜个七七八八。 不过网上答案良莠不齐，有一些说法并不是很准确，而且有些题目不是简简单单几句话就能概括清楚的，这里就打算开一个专栏，每天选取一两个问题详细解答一下，今天就详细说一下Object类的12个方法。 直接奉上这12个方法，下面再展开介绍： Object类有12个...
java中Object类的常用方法
weixin_53066120的博客
11-30 1万+
总之，notify()方法是Java中用于线程间通信的重要方法之一，但需要注意的是，notify()方法只会唤醒等待在当前对象上的一个线程。另外，对于数组对象而言，getClass()方法返回的是描述数组类型的Class对象，而不是数组中元素的类型的Class对象。在Java中，如果两个对象的equals()方法返回true，则它们的哈希码必须相等，即hashCode()方法返回的值相等。需要注意的是，notifyAll()方法会唤醒所有等待在当前对象上的线程，包括已经获取了锁但是还没有执行的线程。
Object类11种方法
热门推荐
qq_45259214的博客
07-25 1万+
Object类 11种方法(部分方法讲解)
js Object方法大全
顺其自然~专栏
05-28 1346
Object 静态方法总结 create 创建一个对象 const obj = Object.create({a:1}, {b: {value: 2}}) 第一个参数为对象，对象为函数调用之后返回新对象的原型对象，第二个参数为对象本身的实例方法（默认不能修改,不能枚举） obj.__proto__.a === 1 // true obj.b = 3; console.log(obj.b) // 2 //创建一个可写的,可枚举的,可配置的属性p obj2 = Object.c
JavaScript中对象（Object）的方法
前端、python爱好者
10-18 4194
JavaScript中对象方法总结： 资料来源：网道-互联网开发文档 【https://wangdoc.com/】 1、Object.getPrototypeOf(Object) Object.getPrototypeOf方法返回参数对象的原型。这是获取原型对象的标准方法。 代码示例： var F = function () {}; var f = new F(); Object.getPrototypeOf(f) === F.prototype // true 几种特殊对象的方
JS中Object的方法汇总，包括assign、create、prototype等等
BWater_monster的博客
04-22 2081
JS中Object的方法汇总，包括assign、create、prototype等等
Js中Object方法
qq_45378746的博客
04-21 3681
1.Object.assign() Object.assign()是通过复制一个或多个对象，创建一个新对象。 var source1 = { a: 1 }; var source2 = { b: 2 }; Object.assign(source1,source2); // {a: 1, b: 2} 注： 1.如果目标对象和源对象有同名属性，或多个源对象有同名属性，后面的属性会覆盖前面的属性。 2.如果只有一个参数，Object.assign会直接返回该参数。 var source1 = { a:
js中Object的常用方法
weixin_44158539的博客
10-21 722
内容后期补上
javascript object array方法使用详解
10-27
在javascript开发中经常会使用到array中方法，本文将对其一一详细介绍，需要了解的朋友可以参考下
Javascript Object 对象学习笔记
10-25
主要介绍了Javascript Object 对象学习笔记,需要的朋友可以参考下
JavaScript中Object基础内部方法图
10-18
本篇文章通过一张详细的JavaScript中Object基础内部方法图介绍了其基本用法，需要的朋友参考下。
JavaScript中利用Array和Object实现Map的方法
10-23
主要介绍了JavaScript中利用Array和Object实现Map的方法,实例分析了javascript实现map的添加、获取、移除、清空、遍历等操作技巧,具有一定参考借鉴价值,需要的朋友可以参考下
【解决NodeJS项目无法在IDEA中调试的问题】使用JetBrains IDEA 2023 调试nodejs项目
宅斗士的博客
04-23 412
项目采用Ant Design Pro + React，使用前后端分离开发方式，后端可以很容易的打断点调试，但是前端用到了React脚手架，在IDEA中加了调试断点，但是没有什么用处。
vue2---修饰符
weixin_45503872的博客
04-24 1057
此时有一个问题，如果我们设置了系统修饰符，并不希望有其他的按键组合，比如我们设置ctrl修饰符，此时如果按住ctrl和其他键，然后再点击鼠标，此时也会触发事件监听，所以我需要使用其他的修饰符来设置精确匹配事件。此时People的data返回的是一个对象，不是一个地址，每一个实例拿到的都是个独立，个体的对象，互相不会数据冲突，这个就是vue组件data为什么是函数的原因。data是一个函数，返回的是一个对象，目的是为了让每个组件数据隔离，这个是JavaScript的原理，并不是vue去设计的。
Redux 状态持久化之 redux-persist 使用示例
笔记、经验、日常分享
04-24 352
同vuex一样，redux中的状态会在刷新浏览器后状态又恢复到初始状态，有些数据想在浏览器刷新后仍然是在最新的状态，不会丢失，就需要借助一些插件实现。本文通过 redux-persist 插件来实现Redux状态的持久化。
用Typescript写自动化工作流
最新发布
联蔚盘云的博客
04-29 688
acao 的命令还有一些其他用法，比如指定执行某个 job 或者忽略依赖 通过命令行参数的方式注入等等，详细使用方式可以查看文档这个项目最近也在持续更新中，后续也会支持更多的预设，web ui 的操作方式也在计划中小伙伴想参与预设的开发也欢迎 pr 呀。
JavaScript函数的作用域
猿码互联
04-23 217
JavaScript函数的作用域指的是变量的可访问范围。在JavaScript中，函数作用域是基于词法作用域（也称为静态作用域）的，意味着函数的作用域在函数被创建时就确定了，而不是在函数被调用时。这样创建的匿名函数会立即执行，并且其中的变量只能在函数内部访问，外部无法访问。这种方式在旧版本的JavaScript中很常见，但在ES6之后，可以直接使用块级作用域来实现同样的效果。需要注意的是，在ES6之前，JavaScript中并没有块级作用域的概念，只有函数作用域和全局作用域。
JavaScript的Object.keys(）方法
08-11
Object.keys() 方法是 JavaScript 中用于获取对象自身可枚举属性的方法。它接受一个对象作为参数，并返回一个包含对象自身可枚举属性名称的数组。 下面是一个示例： ```javascript const obj = { a: 1, b: 2, c: 3...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值