is中创建对象的几种方法

 

1.对象字面量方式创建

var obj = {

            name: "小强",

            age: 22,

            sayName: function () {

                console.log(this.name)

            }

        }

obj.sayName();  //控制台打印出“小强”

2.Object构造函数创建对象

调用js中的Objict构造函数创建new构造函数

var obj2 = new Object();

        obj2.name = '小红';

        obj2.age = 18;

        obj2.sayName = function () {

            console.log(this.name);

        }

        console.log(obj2);

　　obj2.sayName();    //控制台打印出“小美”

使用object构造函数和对象字面量方式创建对象有一个缺点：如果我们想创建与该对象同类型的对象，就会产生大量重复的代码。

3.工厂函数创建对象

function factory(name,age){

            var obj = {};

            obj.name = name;

            obj.age = age;

            return obj;

        }

        var p1 = factory("小猫",20);

        var p2 = factory("小猪",22);

        console.log(p1);   //{name: "小猫", age: 20}

        console.log(p2);  //{name: "小猪", age: 22}

4.构造函数创建对象

 new 一个函数发生了什么？

        1，内部 隐式 创建一个 空对象

        2，改变 函数 的this指向 指向创建的这个空的对象

        3，隐式return 这个对象

        注意：一般构造函数名 首字母大写 为了区分 普通函数 例如：Array Date RegExp Object Function

function Person(name,age){

           this.name = name;

           this.age = age;

       }

       var p1 = new Person("小明",20);

       var p2 = new Person("小猫",19);

       console.log(p1);//Person {name: "小明", age: 20}

        console.log(p2);//Person {name: "小猫", age: 19}

构造函数：生产对象的函数 new 函数()  函数就是构造函数
构造函数不是一个特殊的函数，因为new 它 任意一个函数 new 就会变成构造函数

5.原型模式

每一个构造函数都有一个叫prototype(对象)，叫构造函数的原型（原型空间）

prototype属性中可以存储一些属性和方法，每一个实例对象（new的构造函数），都有一个__proto__属性，

这个属性指向它的构造函数的prototype属性，通过这个实例对象就可以继承原型中存储的方法和属性。

每个对象（除了null外）都会有的属性__proto__,这个属性会指向该对象的原型。

function Person(name,age){

this.name = nae;

this.age = age;

}

Persom.prototype.act() = function(){

console.log("我是原型中的方法")

}

var p1 = new Person("小美",20);

console.log(p1);   // Person {name: "小美", age: 20}

console.log(p1.__proto__   ====  Person.prototype);   //true

console.log(p1.__proto__.act)    //我是原型中的方法

存在原型中的属性 和 方法，在 new 构造函数时，不会开辟多个空间，在内存中永远只存储一份，解决了构造函数的缺点

5.原型链

实例对象中使用一个属性或者方法，先找自己本身（构造函数中定义)有没有属性和方法，如果没有会去找__proto__（构造函数原型中）

如果构造函数的原型中也没有，继续向上去找原型的构造函数的原型，这种链式关系，叫原型链。

原型的最顶层：Object

判断一个变量是不是数组：

var arr = [2,3,4,5]

1.利用constructor  实例对象原型中有一个constructor属性指向实例对象的构造函数

console.log(arr.constructor === Array)    //结果为true

2.instanceof  判断一个对象是不是一个构造函数的实例

console.log(arr instanceof Array);   //结果为true

3.每一种对象的构造函数原型上都有toString（）不同对象调用toString()都是自己构造函数的原型空间

console.log(arr.toString === Array.prototype.toString)   //结果为true