JS创建对象的4种方式

640?wx_fmt=jpeg

来源 | https://www.jianshu.com/p/847bf5f87a7f

创建对象的4种方式

  • 方式一:通过对象字面量表示法(又称为直接量、原始方式)。object literals

  • 方式二:通过new和构造函数Object()、String()等。

  • 方式三:用自定义构造函数来初始化新对象。

  • 方式四:通过Object.create()

方式一:通过对象字面量表示法(又称为直接量、原始方式)object literals

var obj = {name:"zyx456"};

对象字面量是一个名/值对列表,每个名/值对之间用逗号分隔,名和值之间用冒号分隔,最后整体用一个花括号括起来。

属性名可以使用数值,比如5。数值属性名会自动转换为字符串。

var person = {"name" : "Nicholas","age" : 29,5 : true};

属性名一般不加引号,以下情况必须加引号:

  • 属性名中有空格,

  • 有连字符“-”

  • 有关键字,比如“for”。

在ES5(以及ES3的一些实现)中,保留字可以用做不带引号的属性名。然而对于ES3来说,使用保留字作为属性名必须使用引号引起来。

例子:

var person = {	
    name : "Nicholas",	
    age : 29};

在ES5中,对象直接量中的最后一个属性后的逗号可以省略,且在ES3的大部分实现中也可以忽略这个逗号,但在IE中则报错。

使用对象字面量语法时,如果留空其花括号,则可以定义只包含默认属性和方法的空对象。

var obj = {};

对象字面量也可以先创建,再添加属性和方法。

var person = {};         //与new Object()相同	
person.name = "Nicholas";	
person.age = 29;

在通过对象字面量定义对象时,实际上不会调用Object构造函数。

对象可以嵌套对象:

例如:

var myHome={	
        population : "10,000" ,	
        area : "10,000" ,	
        adress : {  // 属性	
                country : "China" ,	
                province : "shanxi" ,	
                city : "xian"	
            },	
        say : function(){  // 方法	
                return "My hometown is very beautiful ! ";	
            }	
    }

//构造嵌套的对象	
var SchoolData = {	
    code: "0123-456-789",	
    Tel: "0551-1234567",	
    Fax: "0551-7654321"	
};	
//构造被嵌入的对象	
var ZGKJDX = {	
    name: "中国科技大学",	
    address: "安徽·合肥",	
    grade: "高等学府",	
    number: "13400",	
    //嵌套对象SchoolData	
    data: SchoolData,	
};

有一个缺点:如果我们想在其他地方创建一个同样的对象,就得把这个对象的所有代码都复制粘贴过去。我们需要一种能够批量创建同样对象的方法,而不是只创建一个对象。

有一个问题:即无法保证属性的顺序。

添加属性的顺序可能并不是遍历输出属性时的顺序。

例如

var o = {}	
o.a = 1	
o.b = 2	
o.c = 3	
for(key in o) console.log(key); // expected a,b,c - but not guaranteed to be in that order

Object 对象也缺乏forEach的方法,不能对object使用通常的迭代方法。

o.forEach // undefined

方式二:通过new和构造函数Object()、String()等。

var obj = new Object();

这里的函数称做构造函数(constructor)。

如下所示:

var person = new Object();	
person.name = "Nicholas";	
person.age = 29

如果构造函数无参数,括号则不是必需的。

因此可以采用下面的形式重写上面的两行代码:

var oObject = new Object;	
var oStringObject = new String;
var str  = new String();	
console.log(str); // 输出的是 String{length:0,[[PrimitiveValue]]:""}	
console.log(typeof str);//object;

JS原始类型都包含内置构造函数。例如:

var o = new Object();           // 创建一个空对象,和{}一样	
var a = new Array();            // 创建一个空数组,和[]一样	
var d = new Date();             // 创建一个表示当前时间的Date对象	
var r = new RegExp("js");       //创建一个可以进行模式匹配的EegExp对象

在JS中,通过 new 运算符来作用与一个函数,实质上会发生这样的过程:

首先,创建一个空对象,然后用函数的apply方法,将这个空对象传入作为 apply 的第一个参数,作为上下文参数。也就是this的指向。

var triangle = new Shape("triangle");	
    //上一句相当于下面的代码	
var triangle = {};	
Shape.apply(triangle, ["triangle"]);

方式三:用自定义构造函数来初始化新对象。

function A(o){	
this.name = "moyu"	
}	
let obj = new a();

例子:

function person(firstname,lastname,age,eyecolor){	
    this.firstname=firstname;	
    this.lastname=lastname;	
    this.age=age;	
    this.eyecolor=eyecolor;	
}	
var myFather=new person("Bill","Gates",56,"blue");	
var myMother=new person("Steve","Jobs",48,"green");

在自定义构造函数的内部定义对象的方法:

function person(firstname,lastname,age,eyecolor)	
{	
    this.firstname=firstname;	
    this.lastname=lastname;	
    this.age=age;	
    this.eyecolor=eyecolor;	

	
    this.changeName=changeName;	
    function changeName(name)	
{	
        this.lastname=name;	
    }	
}

changeName() 函数 name 的值赋给 person 的 lastname 属性。

myMother.changeName("Ballmer");

方式四:通过Object.create()

Object.create()是一个静态函数,而不是提供给某个对象实例调用的方法。

var o1 = Object.create({x:1, y:2}); // o1继承了属性x和y

可以通过任意原型创建新对象(换句话说,可以继承任意对象)。

第一个参数是这个新对象的原型。

第二个参数属性描述符对象propertiesObject,用于对对象的属性进行进一步描述。可选。

属性描述符对象中的属性,默认不可枚举,是继承的属性。

如果propertiesObject指定为 undefined,那么是空对象{}。

如果是null或非原始包装对象,则抛出一个 TypeError 异常。

o = Object.create(Object.prototype, {	
    // foo会成为所创建对象的数据属性	
    foo: {	
        writable:true,	
        configurable:true,	
        value: "hello"	
    },	
    // bar会成为所创建对象的访问器属性	
    bar: {	
        configurable: false,	
        get: function() { return 10 },	
        set: function(value) {	
            console.log("Setting `o.bar` to", value);	
        }	
    }	
});

返回一个新对象,带着指定的原型对象和属性。

例子:

var obj = Object.create({}, {p: {value: 42}});	
Object.values(obj); // => []

上面代码中,Object.create()方法的第二个参数添加的对象属性(属性p),如果不显式声明,默认是不可遍历的,因为p是继承的属性,而不是对象自身的属性。

可以通过传入参数null来创建一个没有原型的新对象,但通过这种方式创建的对象不会继承任何东西,甚至不包括基础方法,比如toString(),也就是说,它将不能和“+”运算符一起正常工作:

var o2 = Object.create(null); //o2不继承任何属性和方法

如果想创建一个普通的空对象(比如通过{}或new Object()创建的对象),需要传入Object.prototype:

var o3 = Object.create(Object.prototype); //o3和{}和new Object()一样

例子:通过原型继承创建一个新对象。

inherit() 返回了一个继承自原型对象p的新对象。

这里使用ES5中的Object.create()函数(如果存在的话)。

如果不存在Object.create(),则退化使用其他方法。

function inherit(p) {	
        if (p == null) throw TypeError();       // p是一个对象,但不能是null	
        if (Object.create)   return Object.create(p);   // 如果Object.create()存在,直接使用它	
        var t = typeof p;                       // 否则进行进一步检测	
        if (t !== "object" && t !== "function") throw TypeError();	
        function f() {};                        // 定义一个空构造函数	
        f.prototype = p;                        //将其原型属性设置为p	
        return new f();                         //使用f()创建p的继承对象	
}	
var o = {};    	
o.x = 1;      	
var p = inherit(o); // p继承o和Object.prototype	
p.y = 2;        	
var q = inherit(p); 	
q.z = 3;      	
var s = q.toString(); 	
q.x + q.y       // => 3: x和y分别继承自o和p

注意,inherit()并不能完全代替Object.create(),它不能通过传入null原型来创建对象,而且不能接收可选的第二个参数。

inherit()函数的其中一个用途就是防止库函数无意间(非恶意地)修改那些不受你控制的对象。

不是将对象直接作为参数传入函数,而是将它的继承对象传入函数。

当函数读取继承对象的属性时,实际上读取的是继承来的值。

如果给继承对象的属性赋值,则这些属性只会影响这个继承对象自身,而不是原始对象:

var o = { x: "don't change this value" };	
library_function(inherit(o));   // 防止对o的意外修改

640?wx_fmt=jpeg

640?wx_fmt=jpeg

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值