JavaScript — this关键字、使用工厂方法创建对象、构造函数

目录

一、this关键字

二、使用工厂方法创建对象

三、构造函数

instanceof 

---

一、this关键字

        解析器在调用函数每次都会向函数内部传递进一个隐含的参数， 这个隐含的参数就是 this，this指向的是一个对象， 这个对象我们称为函数执行的上下文对象，根据函数的调用方式的不同，this会指向不同的对象

        1.以函数的形式调用时，this永远都是window

        2.以方法的形式调用时，this就是调用方法的那个对象

举个例子：

    function fun(){
        console.log(this);
    }
    function Sname(){
        console.log(this.name);
    }
    let obj = {
        name:"Tom",
        sayThis:fun,
        sayName:Sname
    }
    var name = "LiLei"

    // 以函数形式调用，this是window
    fun()
    Sname()
    // 以方法的形式调用，this是调用方法的对象
    obj.sayThis()
    obj.sayName()

 

二、使用工厂方法创建对象

        使用工厂方法创建的对象，使用的构造函数都是Object

        所以创建的对象都是Object这个类型

        就导致我们无法区分出多种不同类型的对象

举个例子：

使用一般的方法创建三个类似的对象：

    var obj = {
        name:"Tom",
        age:12,
        gender:"男",
        sayName:function(){
            console.log(this.name);
        }
    }
    var obj1 = {
        name:"LiLei",
        age:22,
        gender:"男",
        sayName:function(){
            console.log(this.name);
        }
    }
    var obj2 = {
        name:"Jenny",
        age:22,
        gender:"女",
        sayName:function(){
            console.log(this.name);
        }
    }

使用工厂方法批量炮制对象：

    function createPerson(name,age,gender){
        //创建一个新的对象
        var obj = new Object();

        //向对象中添加属性
        obj.name = name;
        obj.age = age;
        obj.gender = gender;
        obj.sayName = function(){
            console.log(this.name);
        }
        //将新的对象返回
        return obj;
    }
    let a = createPerson("Tom",12,"男")
    let b = createPerson("LiLei",23,"男")
    let c = createPerson("Jenny",32,"女")

 

三、构造函数

        创建一个构造函数，专门用来创建Person对象的，构造函数就是一个普通的函数，创建对象和普通函数没有区别，不同的是构造函数习惯上首字母大写

        构造函数和普通函数的区别就是调用方式的不同，普通函数是直接调用，而构造函数需要使用new关键字来调用。

        构造函数执行流程:

    1.立刻创建一个新的对象

    2.将新建的对象设置为函数中的this，在构造函数中可以使用this来引用新建的对象

    3.逐行执行函数中的代码

    4.将新建的对象作为返回值返回

function Person(name,age,gender){
    this.name = name;
    this.age = age;
    this.gender = gender;
    this.sayName = function(){
        alert(this.name)
    }
}
var per =new Person("Tom",12,"男");
var per1 =new Person("LiLei",22,"男");
var per2 =new Person("Jenny",12,"女");
console.log(per);

        使用同一个构造函数创建的对象，我们称为一类对象，也将一个构造函数称为一个类，我们将通过一个构造函数创建的对象，称为是该类的实例

    this的三种情况：

        1.当以函数的形式调用时，this是window

        2.当以方法的形式调用时，谁调用方法this就是谁

        3.当以构造函数的形式调用时，this就是新创建的那个对象

instanceof 

        使用instanceof可以检查一个对象是否是一个类的实例

        语法：

                对象 instanceof 构造函数

        如果是，则返回true，不是则返回false

        所有的对象都是Object的后代，所以任何对象和 Object 做 instanceof 检查时都会返回true

console.log(per instanceof Person); //true
console.log(per instanceof Object); //true

        在上例中创建了一个Person构造函数，在Person构造函数中，为每一个对象都添加了一个sayName方法，目前我们的方法是在构造函数内部创建的，也就是构造函数每执行一次就会创建一个新的sayName方法，也是所有实例的sayName都是唯一的，这样就导致了构造函数执行一次就会创建一个新的方法，执行1000次就会创建1000个新的方法，而1000个方法都是一模一样的。

        这完全没有必要，完全可以使所有的对象共享同一个方法：（将sayName方法定义在全局作用域中）

function Person(name,age,gender){
    this.name = name;
    this.age = age;
    this.gender = gender;
    this.sayName = fun
}
/*
    将sayName方法在全局作用域中定义
    将函数定义在全局作用域，污染了全局作用域的命名空间
    而且定义在全局作用域中很不安全
*/
function fun(){
        alert("Hello,I'm "+this.name)
}

var per =new Person("Tom",12,"男");
var per1 =new Person("LiLei",22,"男");
var per2 =new Person("Jenny",12,"女");
console.log(per.sayName());
console.log(per1.sayName == per2.sayName);  //true