Object 对象属性和方法

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 中的三大对象 (本地对象、内置对象、 宿主对象)

本地对象

 

内置对象

 

宿主对象

 

posted @ 2020-05-11 10:08  elfpower  阅读(4694)  评论(0)  编辑  收藏  举报