1. Factory method
Your own understanding: You need to create many instances of objects, which have the same attributes but have different attribute values. At this time, you need to create a factory function.
Factory function: Creates and returns objects of a specific type.
If an attribute in a factory function is a method, you can define the method of the object outside the factory function and then point to the method through the attribute, so that you can avoid calling your own attribute method every time, so that each object shares the same function.
Example:
<script type="text/javascript">
// Methods to define objects outside the factory function
function ShowNameFn() {
alert();
}
//Create an object using factory
function CreatBOFn(sName, iAge, bSex) {
var BO = new Object();
= sName;
= iAge;
= bSex;
= ShowNameFn; //This property is actually a pointer to a function, which is a method
return BO;
}
//Button test call
function FactoryCreateFn() {
var oPerson1 = CreatBOFn("Zhang San", 18, true); //Creating an instance is actually calling the method directly
();
}
</script>
Summary: Factory functions define a class or object in this way. It calls this factory function when creating an instance.
2. Constructor method
The first step is to select the class name, that is, the name of the constructor, and the first letter of the BO name is capitalized. Looking at the code below, it is found that it is similar to the factory function above.
Example:
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
function Car(color, money) {
= color;
= money;
= function() {
alert();
}
}
//Button call test
function NewCarFn() {
var Car1 = new Car("red", "230,000 RMB");
();
}
//----------------------------------------------------------
Comparing the differences between the previous factory function method:
① The constructor does not create an object inside, but uses this keyword.
② Use the new operator to call the constructor.
3. Prototype method
Using the object's prototype property, it can be regarded as the prototype that depends on creating a new object, and set the class name with an empty constructor, and then all attributes and methods are directly assigned to the prototype property.
Prototype problem:
First of all, this constructor has no parameters. When using the prototype method, the value of the attribute cannot be initialized by passing the parameter to the constructor. The default value of the attribute must be changed after the object is created.
Secondly, when the property points to an object, not a function, the object is shared by multiple instances, and one of the changes will cause changes to the other objects.
Example:
//Define an empty constructor first
function Car() {
}
//Properties and methods directly assign prototype attributes
= "red,";
= "200,000";
= new Array("Miss Three", "Miss Four");
var Car1 = new Car();
("Xiaowu"); //In Example 1, a new value was added to the object Drivers (in fact, an additional "Xiaowu" was added to the prototype, so when new the second object was new, a small five also appeared in the reading attribute Drivers)
alert();
var Car2 = new Car();
alert(); //In Example 2, the value in the object has changed! Output "Miss Three, Small Four, Small Five"
4. Mixed constructor/prototype method
Using constructors and prototypes in combination, you can create objects like other languages.
The constructor defines all non-functional properties of an object, and the function properties (methods) of the object are defined in the prototype.
Example:
function BOStudent(name,age) {
this.name = name;
this.Age = age;
this.Course = new Array("Chinese","Mathematics");
}
= function() {
alert(this.name);
};
//Click the button to debug
function Admixture() {
var stu1 = new BOStudent("Zhang San", 20); //newThe first BO
var stu2 = new BOStudent("Li Si", 22); //new the second BO
stu1. Course.push("Physics"); //Add physics course item to object 1
alert(stu1. Course);
alert(stu2. Course);
}
The hybrid constructor/prototyping method is the main method adopted by ECMAScript, which has other features without their side effects.
5. Dynamic prototype method
Most object-oriented languages, when defining classes, properties and methods are packaged together. The above mixed constructor/prototype method attributes and methods are separated. Some people think that finding attributes inside the constructor and finding methods outside is illogical, so dynamic prototype methods are produced.
The difference is that the method to be assigned to the object is different. The dynamic prototype method is inside the constructor, and the fourth above is outside the constructor.
Example:
function BODynamicPrototype(name, age) {
this.name = name;
this.Age = age;
this.Course = new Array("111", "222");
//_initialized flag determines whether it has been initialized, that is, whether any method has been assigned to the prototype. The method is created and assigned once
if (typeof BODynamicPrototype._initialized == "undefined") {
= function() {
alert(this.name);
};
BODynamicPrototype._initialized = true;
}
}
//Click the button to debug
function DynamicPrototype() {
var stu1 = new BODynamicPrototype("aaa", 20); //new first BO
var stu2 = new BODynamicPrototype("bbb", 22); //new the second BO
stu1. Course.push("333"); //Add physics course item to object 1
alert(stu1. Course);
alert(stu2. Course);
}
6. Mixed factory method
The purpose is to create a fake constructor that returns only a new instance of another object. This method has the same problems as the classic method in terms of internal management of object methods. Strongly advise: avoid using it unless absolutely necessary!
Your own understanding: You need to create many instances of objects, which have the same attributes but have different attribute values. At this time, you need to create a factory function.
Factory function: Creates and returns objects of a specific type.
If an attribute in a factory function is a method, you can define the method of the object outside the factory function and then point to the method through the attribute, so that you can avoid calling your own attribute method every time, so that each object shares the same function.
Example:
Copy the codeThe code is as follows:
<script type="text/javascript">
// Methods to define objects outside the factory function
function ShowNameFn() {
alert();
}
//Create an object using factory
function CreatBOFn(sName, iAge, bSex) {
var BO = new Object();
= sName;
= iAge;
= bSex;
= ShowNameFn; //This property is actually a pointer to a function, which is a method
return BO;
}
//Button test call
function FactoryCreateFn() {
var oPerson1 = CreatBOFn("Zhang San", 18, true); //Creating an instance is actually calling the method directly
();
}
</script>
Summary: Factory functions define a class or object in this way. It calls this factory function when creating an instance.
2. Constructor method
The first step is to select the class name, that is, the name of the constructor, and the first letter of the BO name is capitalized. Looking at the code below, it is found that it is similar to the factory function above.
Example:
Copy the codeThe code is as follows:
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
function Car(color, money) {
= color;
= money;
= function() {
alert();
}
}
//Button call test
function NewCarFn() {
var Car1 = new Car("red", "230,000 RMB");
();
}
//----------------------------------------------------------
Comparing the differences between the previous factory function method:
① The constructor does not create an object inside, but uses this keyword.
② Use the new operator to call the constructor.
3. Prototype method
Using the object's prototype property, it can be regarded as the prototype that depends on creating a new object, and set the class name with an empty constructor, and then all attributes and methods are directly assigned to the prototype property.
Prototype problem:
First of all, this constructor has no parameters. When using the prototype method, the value of the attribute cannot be initialized by passing the parameter to the constructor. The default value of the attribute must be changed after the object is created.
Secondly, when the property points to an object, not a function, the object is shared by multiple instances, and one of the changes will cause changes to the other objects.
Example:
Copy the codeThe code is as follows:
//Define an empty constructor first
function Car() {
}
//Properties and methods directly assign prototype attributes
= "red,";
= "200,000";
= new Array("Miss Three", "Miss Four");
var Car1 = new Car();
("Xiaowu"); //In Example 1, a new value was added to the object Drivers (in fact, an additional "Xiaowu" was added to the prototype, so when new the second object was new, a small five also appeared in the reading attribute Drivers)
alert();
var Car2 = new Car();
alert(); //In Example 2, the value in the object has changed! Output "Miss Three, Small Four, Small Five"
4. Mixed constructor/prototype method
Using constructors and prototypes in combination, you can create objects like other languages.
The constructor defines all non-functional properties of an object, and the function properties (methods) of the object are defined in the prototype.
Example:
Copy the codeThe code is as follows:
function BOStudent(name,age) {
this.name = name;
this.Age = age;
this.Course = new Array("Chinese","Mathematics");
}
= function() {
alert(this.name);
};
//Click the button to debug
function Admixture() {
var stu1 = new BOStudent("Zhang San", 20); //newThe first BO
var stu2 = new BOStudent("Li Si", 22); //new the second BO
stu1. Course.push("Physics"); //Add physics course item to object 1
alert(stu1. Course);
alert(stu2. Course);
}
The hybrid constructor/prototyping method is the main method adopted by ECMAScript, which has other features without their side effects.
5. Dynamic prototype method
Most object-oriented languages, when defining classes, properties and methods are packaged together. The above mixed constructor/prototype method attributes and methods are separated. Some people think that finding attributes inside the constructor and finding methods outside is illogical, so dynamic prototype methods are produced.
The difference is that the method to be assigned to the object is different. The dynamic prototype method is inside the constructor, and the fourth above is outside the constructor.
Example:
Copy the codeThe code is as follows:
function BODynamicPrototype(name, age) {
this.name = name;
this.Age = age;
this.Course = new Array("111", "222");
//_initialized flag determines whether it has been initialized, that is, whether any method has been assigned to the prototype. The method is created and assigned once
if (typeof BODynamicPrototype._initialized == "undefined") {
= function() {
alert(this.name);
};
BODynamicPrototype._initialized = true;
}
}
//Click the button to debug
function DynamicPrototype() {
var stu1 = new BODynamicPrototype("aaa", 20); //new first BO
var stu2 = new BODynamicPrototype("bbb", 22); //new the second BO
stu1. Course.push("333"); //Add physics course item to object 1
alert(stu1. Course);
alert(stu2. Course);
}
6. Mixed factory method
The purpose is to create a fake constructor that returns only a new instance of another object. This method has the same problems as the classic method in terms of internal management of object methods. Strongly advise: avoid using it unless absolutely necessary!