Object 對象屬性和方法

本文轉載自查看原文 2020-05-11 10:08 2558 前端 - JS - 對象/ 前端 - JS

Object 對象

在 JvaScript 中，幾乎所有的對象都是 Object 類型的實例，它們都會從 Objet.prototype 繼承屬性和方法。Object 構造函數為給定值創建一個對象包裝器，根據給定的參數創建對象，具體有以下情況：

如果給定值是 null 或 undefined，將會創建並返回一個空對象
如果傳進去的是一個基本類型的值，則會構造其包裝類型的對象
如果傳進去的是引用類型的值，仍然會返回這個值，經他們復制的變量保有和源對象相同的引用地址
當以非構造函數形式被調用時，Object 的行為等同於 new Object()。

也可以通過 new Object()， Object.create() 方法，或者使用字面量標記（初始化標記）初始化對象：

new Object()
Object.create()
{}

Object 與其實例的屬性和方法：

// Object.getOwnPropertyDescriptors(Object):
name                         : {value: "Object", writable: false, enumerable: false, configurable: true}
length                       : {value: 1, writable: false, enumerable: false, configurable: true}
prototype                    : {value: {…}, writable: false, enumerable: false, configurable: false}
assign                       : {writable: true, enumerable: false, configurable: true, value: ƒ}
create                       : {writable: true, enumerable: false, configurable: true, value: ƒ}
defineProperties             : {writable: true, enumerable: false, configurable: true, value: ƒ}
defineProperty               : {writable: true, enumerable: false, configurable: true, value: ƒ}
entries                      : {writable: true, enumerable: false, configurable: true, value: ƒ}
freeze                       : {writable: true, enumerable: false, configurable: true, value: ƒ}
fromEntries                  : {writable: true, enumerable: false, configurable: true, value: ƒ}
getOwnPropertyDescriptor     : {writable: true, enumerable: false, configurable: true, value: ƒ}
getOwnPropertyDescriptors    : {writable: true, enumerable: false, configurable: true, value: ƒ}
getOwnPropertyNames          : {writable: true, enumerable: false, configurable: true, value: ƒ}
getOwnPropertySymbols        : {writable: true, enumerable: false, configurable: true, value: ƒ}
getPrototypeOf               : {writable: true, enumerable: false, configurable: true, value: ƒ}
is                           : {writable: true, enumerable: false, configurable: true, value: ƒ}
isExtensible                 : {writable: true, enumerable: false, configurable: true, value: ƒ}
isFrozen                     : {writable: true, enumerable: false, configurable: true, value: ƒ}
isSealed                     : {writable: true, enumerable: false, configurable: true, value: ƒ}
keys                         : {writable: true, enumerable: false, configurable: true, value: ƒ}
preventExtensions            : {writable: true, enumerable: false, configurable: true, value: ƒ}
seal                         : {writable: true, enumerable: false, configurable: true, value: ƒ}
setPrototypeOf               : {writable: true, enumerable: false, configurable: true, value: ƒ}
values                       : {writable: true, enumerable: false, configurable: true, value: ƒ}

// Object.getOwnPropertyDescriptors(Object.prototype):
constructor                  : {writable: true, enumerable: false, configurable: true, value: ƒ}
valueOf                      : {writable: true, enumerable: false, configurable: true, value: ƒ}
toString                     : {writable: true, enumerable: false, configurable: true, value: ƒ}
toLocaleString               : {writable: true, enumerable: false, configurable: true, value: ƒ}
hasOwnProperty               : {writable: true, enumerable: false, configurable: true, value: ƒ}
isPrototypeOf                : {writable: true, enumerable: false, configurable: true, value: ƒ}
propertyIsEnumerable         : {writable: true, enumerable: false, configurable: true, value: ƒ}
__defineGetter__             : {writable: true, enumerable: false, configurable: true, value: ƒ}
__defineSetter__             : {writable: true, enumerable: false, configurable: true, value: ƒ}
__lookupGetter__             : {writable: true, enumerable: false, configurable: true, value: ƒ}
__lookupSetter__             : {writable: true, enumerable: false, configurable: true, value: ƒ}

Object 的常用方法描述

方法	描述
create()	創建一個對象，其原型為prototype，同時可添加多個屬性。
assign()	把一個或多個源對象的可枚舉、自有屬性值復制到目標對象中，返回值為目標對象。
defineProperty()	在一個對象上定義一個新屬性或修改一個現有屬性，並返回該對象。
defineProperties()	在一個對象上定義一個或多個新屬性或修改現有屬性，並返回該對象。
getOwnPropertyDescriptor()	獲取目標對象上某自有屬性的配置特性（屬性描述符），返回值為配置對象。
getOwnPropertyDescriptors()	獲取目標對象的所有自身屬性的描述符，如果沒有任何自身屬性，則返回空對象。
getOwnPropertyNames()	獲取目標對象上的全部自有屬性名（包括不可枚舉屬性）組成的數組。
getOwnPropertySymbols()	返回目標對象自身的所有 Symbol 屬性的數組。
getPrototypeOf()	獲取指定對象的原型，即目標對象的prototype屬性的值。
setPrototypeOf()	設置目標對象的原型為另一個對象或null，返回該目標對象。
seal()	密封對象，阻止其修改現有屬性的配置特性，即將對象的所有屬性的configurable特性設置為false（也就是全部屬性都無法重新配置，唯獨可以把writable的值由true改為false，即凍結屬性），並阻止添加新屬性，返回該對象。
freeze()	完全凍結對象，在seal的基礎上，屬性值也不可以修改，即每個屬性的wirtable也被設為false。
preventExtensions()	使某一對象不可擴展，也就是不能為其添加新屬性。
is()	判斷兩個值是否是相同的值
isSealed()	用於判斷目標對象是否被密封，返回布爾值。
isFrozen()	用於判斷目標對象是否被凍結，返回布爾值。
isExtensible()	用於判斷一個對象是否可擴展，即是否可以添加新屬性。
keys()	獲取目標對象上所有可枚舉屬性組成的數組。
entries()	返回目標對象可枚舉屬性的鍵值對的數組。
fromEntries()	把目標鍵值對列表轉換為一個對象。
values(obj)	返回目標對象自身的所有可枚舉屬性值的數組，值的順序與使用for...in循環的順序相同 ( 區別在於 for-in 循環枚舉原型鏈中的屬性 )。

Object 對象方法

1.Object.assign(target, ...sources)

功能：把一個或多個源對象的可枚舉、自有屬性值復制到目標對象中，返回值為目標對象。
參數：

target：目標對象（必須）
sources：至少一個源對象（可選）

返回值：目標對象。（原目標對象會被改變）

常用於：復制一個對象、合並多個對象、合並具有相同屬性的對象

示例：

var target = { a: 1, b: 2 };
var source1 = { b: 4, c: 5 };
var source2 = { d: 4, e: 5 };
var source3 = { f: 4, g: 5 };
var source4 = { h: 4, i: 5 };

var returnedTarget = Object.assign(target,source1,source2,source3,source4,{z:8,y:9});

console.log(returnedTarget); // {a: 1 b: 4 c: 5 d: 4 e: 5 f: 4 g: 5 h: 4 i: 5 z: 8 y: 9}
console.log(target); // {a: 1 b: 4 c: 5 d: 4 e: 5 f: 4 g: 5 h: 4 i: 5 z: 8 y: 9} 原目標對象已被改變

自定義實現一個assign方法：

//自定義一個assign方法
  function copy(target){
    if(target == null){
      throwError('出錯：Cannot convert undefined or null to object');
    }
    var target = new Object(target);
    for(var i = 1;i < arguments.length;i ++){
      var source = arguments[i];
      for(var key in source){
        if(source.hasOwnProperty(key)){
          //若當前屬性為源對象自有屬性，則拷貝至目標對象
          target[key] = source[key];
        }
      }
    }
    return target;
  }

2.Object.create(proto [,propertiesObject])

功能：創建一個對象，其原型為prototype，同時可添加多個屬性。
參數：

proto(必須)：原型對象，可以為null表示沒有原型。
propertiesObject(可選)：包含一個或多個屬性描述符的對象。

propertiesObject參數：

數據屬性
- value：值
- writable：是否可修改屬性的值
- configurable：是否可通過delete刪除屬性，重新定義
- enumerable：是否可for-in枚舉
訪問屬性
- get()：訪問
- set()：設置

返回值：一個新對象，帶着指定的原型對象和屬性。

常用於：生成一個新對象、繼承。

示例：

function Person(name){
    this.name = name;
}
Person.prototype.say = function(){
    console.log('我叫' + this.name +',我是'+ this.sex +',我今年 ' + this.age + '歲了');
}

var person = new Person('gwg');
var p = Object.create(person,{
    age:{
      value: 23,
      writable: true,
      configurable: true
    },
    sex:{
      configurable: true,
      get:function(){return sex + '生';},
      set:function(value){sex = value;}
    }
});

p.sex = '男';
p.say(); // 我叫gwg,我是男生,我今年 23歲了
console.log(p.sex);  // 男生
p.sex = '女';
p.age = 15;
p.name = 'may';
console.log(p.sex);  // 女生
console.log(p.age);  // 15
p.say(); // 我叫may,我是女生,我今年 15歲了

Object.create(proto [,propertiesObject]) 是E5中提出的一種新的對象創建方式，第一個參數是要繼承的原型，如果不是一個子函數，可以傳一個null，第二個可選參數是對象的屬性描述符。

3.Object.defineProperty(obj, prop, descriptor)

功能：在一個對象上定義一個新屬性或修改一個現有屬性，並返回該對象。

參數：

obj（必須）：被操作的目標對象
prop（必須）：被定義或修改的目標屬性
descriptor（必須）：屬性的描述符

descriptor參數：

數據屬性
- value：值 ( 默認為 undefined)
- writable：是否可修改屬性的值 ( 默認為 false)
- configurable：是否可通過delete刪除屬性，重新定義 ( 默認為 false)
- enumerable：是否可for-in枚舉 ( 默認為 false)
訪問屬性
- get()：訪問 ( 默認為 undefined)
- set()：設置 ( 默認為 undefined)

示例：

var obj = {};
Object.defineProperty(obj,'name',{
    writable: true,
    configurable: true,
    enumerable: false,
    value: '張三'
});

console.log(obj.name); //'張三'
for(var key in obj){
    console.log(obj[key]); //無結果
}

注意：

var obj = {};

obj.a = 1;
// 等同於：
Object.defineProperty(obj, "a", {
  value: 1,
  writable: true,
  configurable: true,
  enumerable: true
});


// 另外，
Object.defineProperty(obj, "a", { value : 1 });
// 等同於：
Object.defineProperty(obj, "a", {
  value: 1,
  writable: false,
  configurable: false,
  enumerable: false
});

自定義 getter 和 setter：

function CustomizeObject() {
    var attr = null;
    var saveArr = [];

    Object.defineProperty(this, 'attr', {
        get: function() {
            console.log('get attr');
            return attr;
        },
        set: function(value) {
            attr = value;
            saveArr.push({ val: attr });
        }
    });

    this.getSaveArr = function() { return saveArr; };
}
  
var obj = new CustomizeObject();
obj.attr; // 'get attr'
obj.attr = 11;
obj.attr = [1,2,3,4];
obj.getSaveArr(); // [{val: 11},{val:[1, 2, 3, 4]}]
obj.attr = {a:5,b:6};
obj.attr = 'gwg';
obj.getSaveArr(); // [{val: 11},{val:[1, 2, 3, 4]},{val: {a: 5, b: 6}},{val: "gwg"}]

在vue中通過Object.defineProperty()來劫持各個屬性的setter，getter，在數據變動時發布消息給訂閱者，觸發相應的監聽回調，實現數據綁定；

4.Object.defineProperties(obj, props)

功能：在一個對象上定義一個或多個新屬性或修改現有屬性，並返回該對象。

參數：

obj（必須）：被操作的目標對象
props（必須）：該對象的一個或多個鍵值對定義了將要為對象添加或修改的屬性的具體配置

示例：

var obj = {};
Object.defineProperties(obj,{
    name:{
      writable: true,
      configurable: true,
      enumerable: false,
      value: 'gwg'
    },
    age:{
      writable: true,
      configurable: true,
      enumerable: true,
      value: 23
    }

});

console.log(obj.name); //'gwg'
console.log(obj.age); //23
for(var key in obj){
    console.log(obj[key]); //23
}

作用和Object.defineProperty(obj, prop, descriptor) 基本相同，可一次定義目標對象多個屬性

5.Object.seal(obj)
功能：密封對象，阻止其修改現有屬性的配置特性，即將對象的所有屬性的configurable特性設置為false（也就是全部屬性都無法重新配置，唯獨可以把writable的值由true改為false，即凍結屬性），並阻止添加新屬性，返回該對象。

參數：

obj（必須）：被密封的對象

示例：

var obj = {name:'gwg'};

Object.seal(obj);
console.log(Object.isSealed(obj)); //true

obj.name = 'power'; //修改值成功
console.log(obj.name); //'power'
obj.age = 23; //無法添加新屬性
console.log(obj.age); //undefined

Object.defineProperty(obj,'name',{ 
    writable: true,
    configurable: true,
    enumerable: true
}); //報錯：Cannot redefine property: name

6.Object.isSealed(obj)

功能：用於判斷目標對象是否被密封，返回布爾值。

參數：

obj（必須）：被檢測是否密封的對象

示例：

// 新建的對象默認不是密封的.
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 ，訪問器屬性不考慮可寫不可寫,只考慮是否可配置

將一個對象密封后僅能保證該對象不被擴展且全部屬性不可重配置，但是原屬性值卻是可以被修改的。

7.Object.freeze(obj)

功能：完全凍結對象，在seal的基礎上，屬性值也不可以修改，即每個屬性的wirtable也被設為false。

參數：

obj（必須）：被凍結的對象

示例：

var obj = {name:'gwg'};

Object.freeze(obj);
console.log(Object.isFrozen(obj)); //true

obj.name = 'power'; //修改值失敗
console.log(obj.name); //'gwg'
obj.age = 23; //無法添加新屬性
console.log(obj.age); //undefined

Object.defineProperty(obj,'name',{ 
    writable: true,
    configurable: true,
    enumerable: true
}); //報錯：Cannot redefine property: name

8.Object.isFrozen(obj)

功能：用於判斷目標對象是否被凍結，返回布爾值。

參數：

obj（必須）：檢測是否被凍結的對象

示例：

// 一個對象默認是可擴展的,所以它也是非凍結的.
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

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

10.Object.isExtensible(obj)

功能：方法用於判斷一個對象是否可擴展，即是否可以添加新屬性。

參數：

obj(必須)：需要檢測的對象

示例：

// 新對象默認是可擴展的.
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

11.Object.getOwnPropertyDescriptor(obj, prop)

功能：獲取目標對象上某自有屬性的配置特性（屬性描述符），返回值為配置對象。

參數：

obj(必須)：目標對象
prop(必須)：目標自有屬性

示例：

var a, b;

a = { get foo() { return 17; } };
b = Object.getOwnPropertyDescriptor(a, "foo"); //  b{set: undefined, enumerable: true, configurable: true, get: ƒ}

a = { bar: 42 };
b = Object.getOwnPropertyDescriptor(a, "bar"); // b{value: 42, writable: true, enumerable: true, configurable: true}

a = {};
Object.defineProperty(a, "baz", {
  value: 'gwg',
  writable: false,
  enumerable: false
});
b = Object.getOwnPropertyDescriptor(a, "baz"); // b{value: "gwg", writable: false, enumerable: false, configurable: false}

12.Object.getOwnPropertyNames(obj)

功能：獲取目標對象上的全部自有屬性名（包括不可枚舉屬性）組成的數組。

參數：

obj(必須)：目標對象

示例：

var obj = {};
obj.say = function(){};

Object.defineProperties(obj,{
    name:{
      writable: true,
      configurable: true,
      enumerable: true,
      value: 'gwg'
    },
    age:{
      writable: true,
      configurable: true,
      enumerable: false,
      value: 23
    }
});

var arr = Object.getOwnPropertyNames(obj);
console.log(arr); //["say", "name", "age"]

13.Object.getPrototypeOf(obj)

功能：獲取指定對象的原型，即目標對象的prototype屬性的值。

參數：

obj(必須)：目標對象

示例：

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

var person = new Person('gwg');
var p = Object.create(person); //對象p的原型為person
console.log(p); //Person {}

var __ptoto__ = Object.getPrototypeOf(p);
console.log(__ptoto__); //Person {name: "gwg"}
Object.getPrototypeOf(p) === person; // true

14.Object.setPrototypeOf(obj, proto)

功能：設置目標對象的原型為另一個對象或null，返回該目標對象。

參數：

obj(必須)：目標對象
proto(必須)：原型對象

示例：

var obj = {a:1};
var proto = {};
Object.setPrototypeOf(obj,proto); //設置obj對象的原型

proto.b = 2; //為該原型對象添加屬性
proto.c = 3;


console.log(obj.a); //1
console.log(obj.b); //2
console.log(obj.c); //3

上述代碼將proto對象設為obj對象的原型，所以從obj對象上可以順利讀取到proto 對象的屬性，也就是原型鏈上的屬性。

Object.setPrototypeOf()方法的作用與__proto__相同，用來設置當前對象的原型指向的對象(prototype)。它是 ES6 正式推薦的設置原型對象的方法。

15.Object.keys(obj)

功能：獲取目標對象上所有可枚舉屬性組成的數組。

參數：

obj(必須)：目標對象

示例：

var person = {
    type:'person',
    say:function(){}
  };
  //以person對象為原型，創建obj對象
  var obj = Object.create(person,{
    sex:{
      writable: true,
      configurable: true,
      enumerable: false, //設置sex屬性為不可枚舉
      value: 'male'
    },
    age:{
      writable: true,
      configurable: true,
      enumerable: true, //設置age屬性為可枚舉
      value: 23
    }
  });

  obj.name = 'gwg'; //自定義屬性name默認為可枚舉
  console.log(obj.propertyIsEnumerable('name')); //true，成功驗證name屬性為可枚舉

  //用for-in可獲取obj上全部可枚舉的屬性（包括自有和原型鏈上的）
  var arr = [];
  for(var key in obj){
    arr.push(key);
  }
  console.log(arr); //["age", "name", "type", "say"]

  //用Object.keys()可獲取obj上全部可枚舉的自有屬性
  console.log(Object.keys(obj)); // ["age", "name"]

Object.keys(obj)方法獲取的集合和for-in遍歷獲取的不同在於，Object.keys()只獲取目標對象上可枚舉的自有屬性，而for-in遍歷會包含原型鏈上可枚舉屬性一並獲取。

Object.keys()和Object.getOwnPropertyNames()的相同之處都是獲取目標對象的自有屬性，區別在於，后者會連同不可枚舉的自有屬性也一並獲取組成數組並返回。

Object.prototype 對象方法

1.obj.toString()

功能：返回當前對象的字符串形式，返回值為String類型。

示例：

var oArr = [1,2,3];
var oFlag = true;
var oDate = new Date();
var oFun = function () {var f = {g:8};return f};
var oMan = {name:'gwg',age:18};

oArr.toString(); // "1,2,3"
oFlag.toString(); // true
oDate.toString(); // "Wed Jan 01 2020 08:00:00 GMT+0800 (中國標准時間)"
oFun.toString(); // "function () {var f = {g:8};return f}"
oMan.toString(); // "[object Object]"

該方法屬於Object對象，由於所有的對象都"繼承"了Object的對象實例，因此幾乎所有的實例對象都可以使用該方法。

JavaScript的許多內置對象都重寫了該函數，以實現更適合自身的功能需要。

2.obj.toLocaleString()

功能：返回當前對象的"本地化"字符串形式，以便於當前環境的用戶辨識和使用，返回值為String類型。

示例：

var oNum = 1234567;
var oArr = [1234234234,2,3,4444,'fffffff',55555,6,7,890890890];
var oDate = new Date('2222');

oNum.toLocaleString();// "1,234,567" (數字每3位添加“,”進行分隔)
oArr.toLocaleString(); // "1,234,234,234,2,3,4,444,fffffff,55,555,6,7,890,890,890"
oDate.toLocaleString(); // "2222/1/1 上午8:00:00" (本地化時間)

3.obj.valueOf()

功能：返回指定對象的原始值。

Array 返回數組對象本身。
Boolean 布爾值。
Date 存儲的時間是從 1970 年 1 月 1 日午夜開始計的毫秒數 UTC。
Function 函數本身。
Number 數字值。
Object 對象本身。這是默認情況。
String 字符串值。
Math 和 Error 對象沒有 valueOf 方法。

示例：

// Array：返回數組對象本身
var array = [123,true,{a:2},'gwg'];
console.log(array.valueOf() === array); // true

// 布爾：返回布爾值
var bool = true;
console.log(bool.valueOf() === bool);   // true
// new一個Boolean對象
var newBool = new Boolean(true);
// valueOf()返回的是true，兩者的值相等
console.log(newBool.valueOf() == newBool);   // true
// 但是不全等，兩者類型不相等，前者是boolean類型，后者是object類型
console.log(newBool.valueOf() === newBool);   // false

// Date：返回當前時間距1970年1月1日午夜的毫秒數
var date = new Date(2111, 11, 11, 11, 11, 11, 111);
console.log(date.valueOf());   // 4479246671111

// Function：返回函數本身
function fun(){}
console.log( fun.valueOf() === fun );   // true
var fun2 =  new Function("x", "y", "return x + y;");
console.log(fun2.valueOf()); //  ƒ anonymous(x,y ) { return x + y; }

// Number：返回數字值
var num =  -123.456;
console.log(num.valueOf() === num);   // true

// Object：返回對象本身
var obj = {name: "gwg", age: 18};
console.log( obj.valueOf() === obj);   // true

// String：返回字符串值
var str = "gwg";
console.log( str.valueOf() === str);   // true
// new一個字符串對象
var str2 = new String("gwg2");
// 兩者的值相等，但不全等，因為類型不同，前者為string類型，后者為object類型
console.log( str2.valueOf() === str2 );   // false

JavaScript的許多內置對象都重寫了該函數，以實現更適合自身的功能需要。因此，不同類型對象的valueOf()方法的返回值和返回值類型均可能不同。

4.obj.hasOwnProperty(prop)

功能：返回一個布爾值，表示某個對象是否含有指定的屬性，而且此屬性非原型鏈繼承的。

示例：

// 即使屬性的值是 null 或 undefined，只要屬性存在，hasOwnProperty 依舊會返回 true。
o = new Object();
o.hasOwnProperty('prop'); // 返回 false
o.prop = 'exists';
o.hasOwnProperty('prop'); // 返回 true
delete o.prop;
o.hasOwnProperty('prop'); // 返回 false

// 繼承屬性返回false
o.hasOwnProperty('toString');         // 返回 false
o.hasOwnProperty('hasOwnProperty');   // 返回 false

5.obj.isPrototypeOf(o)

功能：返回一個布爾值，表示指定的對象是否在本對象的原型鏈中。

示例：

var obj = {a:1}
var o = Object.create(obj);

obj.isPrototypeOf(o);// true
Object.prototype.isPrototypeOf(obj);// true

6.obj.propertyIsEnumerable(prop)

功能：方法返回一個布爾值，表示指定的屬性是否可枚舉。

示例：

var obj = {a:55}
var arr = [,66,]

obj.b = 77;
arr[5] = 88;

console.log(obj.propertyIsEnumerable('b'));// true

console.log(arr.propertyIsEnumerable(0));// false
console.log(arr.propertyIsEnumerable(1));// true
console.log(arr.propertyIsEnumerable(5));// true
console.log(arr.propertyIsEnumerable('length'));// false

JavaScript 中的三大對象 (本地對象、內置對象、宿主對象)

本地對象

內置對象

宿主對象

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Object.keys()方法返回對象屬性數組淺談js對象之數據屬性、訪問器屬性、Object.defineProperty方法獲取一個 Object 對象的所有屬性獲取List