建立对象的4种方式

建立对象的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的意外修改