Simple analysis of JavaScript object-oriented and prototype_jquery

The main content of this article comes from JavaScript advanced programming, object-oriented and prototype chapters:

1. Factory mode

ECMAScript can create objects through the factory pattern:

//工厂模式
function createObject(name, age) {
  var obj = new Object();                  //创建对象
  obj.name = name;                      //添加属性
  obj.age = age;
  obj.run = function () {                    //添加方法
    return this.name + this.age + '运行中...';
  };
  return obj;                            //返回对象引用
};
var obj1 = createObject('Lee', 100);          //创建第一个对象
var obj2 = createObject('Jack', 200);          //创建第二个对象
//alert(obj1.run());                          //打印第一个对象实例的run()方法
//alert(obj2.run());                          //打印第二个对象实例的run()方法

//alert(typeof obj1);
//alert(typeof obj2);
alert(obj1 instanceof Object); //true
alert(obj2 instanceof Object); //true

Objects created through the factory pattern solve the problem of repeated instantiation, but the object recognition problem cannot be solved (all objects are Objects), so to solve the object recognition problem, we use the following constructor.

2. Constructor

//构造函数创建
function Person(name,age){  //所有构造函数对象都是Object
  this.name=name;
  this.age=age;
  this.run=function(){
    return this.name+this.age+"ing...";
  };
};
var person1=new Person('zhu1',100);
var person2=new Person('zhu2',200);
alert(person1.run());
alert(person2.run());

alert(person1 instanceof Object); //ture
alert(typeof person2);         //Person
alert(person2 instanceof Person);  // true
var person3=new Object();
Person.call(person3,'zhu3',300);//对象冒充,person3是Object类型，冒充Person类型
alert(person3.run()); 

This in the constructor: represents the reference to the current scope object. If it is in the global scope, this represents the window object. If it is in the constructor body, it represents the object declared by the current constructor.

The constructor method solves the problem of repeated instantiation and object identification. Comparing the differences with the factory method, we can see:

1. The constructor method does not create an object (new Object()) explicitly;

2. Directly assign attribute and method values ​​to this;

3. No return statement;

4. However, when creating using a constructor, you must use the new operator;

The above is the entire content of this article, I hope you all like it.