Web Front-end
JS Tutorial
JavaScript object-oriented - creating objects using factory methods and constructor methods
JavaScript object-oriented - creating objects using factory methods and constructor methods
In the previous article, we introduced the creation method of simple JavaScript objects. The biggest problem with simple js objects is that there is no class constraint, so the reuse of objects cannot be realized, and there is no convention that will bring problems during operation. Come to question. So people borrowed a factory pattern from design patterns to create JavaScript objects.
Use factory methods to create JavaScript objects
The idea of the factory method is to create an object in a function, then set the corresponding properties and methods for the object, and finally return the object. Encapsulate through functions and create objects with specific interfaces. The following is an example of using the factory method to create a person object:
function createPerson(name,age){
var o = new Object();
o.name = name;
o.age = age;
o.say = function(){
alert(this.name + "," + this.age);
}
return o;
}
// 实例化p1和p2对象
var p1 = createPerson("Leon",22);
var p2 = createPerson("Ada",20);
//调用p1和p2对象的say()方法
p1.say();
p2.say();Although using the factory method effectively solves the class problem, there is still another problem. We cannot detect the data type of objects p1 and p2. We can only use typeof to detect that the object is an Object type:
console.info(typeof p1); // 控制台输出：Object
If we want to use instanceof to determine the type of the object, then p1 instanceof?, what type should be filled in after instanceof? We don't know.
Use constructors to create JavaScript objects
Since the factory method cannot determine the specific type of the object, people have proposed a new method of creating JavaScript objects-the constructor method. In JavaScript, constructors can be used to create specific types of objects. For example, these js native constructors such as Object and Array will automatically appear in the execution environment at runtime. We can also customize the constructor to define properties and methods of custom types.
The method of using a constructor to create a class is similar to the method of creating a class based on a factory. The biggest difference is that the name of the function is the name of the class. Usually according to the convention of programming standards, the first letter of a class is capitalized. When using a constructor to create a class, the attribute definition is completed through the this keyword inside the function.
// 使用构造函数方式来创建Person类
function Person(name,age){
this.name = name;
this.age = age;
this.say = function(){
console.info(this.name + "," + this.age);
}
}
// 通过new关键字来创建对象
var p1 = new Person("Leon",22);
var p2 = new Person("Ada",20);
// 调用对象的方法
p1.say();
p1.say();As shown in the above code, after completing the creation of the class, we can instantiate the object through the new keyword.
The method of using the constructor solves the problem of detecting the object type very well. We can use the instanceof keyword to determine whether the object is a Person type:
console.info(p1 instanceof Person); //控制台显示：true console.info(p2 instanceof Person); //控制台显示：true
In addition, we can also use the constructor Keyword to check whether the object's constructor is of type Person:
console.info(p1.constructor == Person); //控制台显示：true console.info(p2.constructor == Person); //控制台显示：true
Or directly print out the constructors of p1 and p2 for comparison:
console.info(p1.constructor); console.info(p2.constructor);
The problem that using the constructor method brings to us is that there will be a copy of the method in each object. If the object has many methods, it will occupy a lot of memory space.
In some advanced compiled object-oriented programming languages (such as Java), object methods are dynamically generated in the stack area at runtime, and they do not occupy memory. In Javascript, for objects created using the constructor method, each method in the object is a copy of the class method. If there are a large number of methods in the object, it will occupy a lot of memory space.
We can define the class methods in global variables, so that the methods in the class can point to the same function. The code is as follows:
// 使用构造函数方式来创建Person类
function Person(name,age){
this.name = name;
this.age = age;
// 此时的类方法是一个全局方法的引用
this.say = say;
}
//将方法设置为全局的方法
function say(){
alert(this.name + "," + this.age);
}By setting the class method as a global method, the problem of methods in the object occupying memory space can be solved. At this time, the methods in all objects created through the constructor point to the same global function.
But if all methods are set as global functions, these functions can be called by the window, which destroys the encapsulation of the object, and if an object has a large number of methods, it will cause code There are a large number of global functions in it, which is not conducive to our development.
In order to solve these shortcomings of the constructor method, we must use prototypes to create objects. In the next article, we will introduce the use of prototypes to create JavaScript objects.
The above is the content of JavaScript object-oriented - using factory methods and constructor methods to create objects. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!
Hot AI Tools
Undresser.AI Undress
AI-powered app for creating realistic nude photos
AI Clothes Remover
Online AI tool for removing clothes from photos.
Undress AI Tool
Undress images for free
Clothoff.io
AI clothes remover
Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!
Hot Article
Hot Tools
Notepad++7.3.1
Easy-to-use and free code editor
SublimeText3 Chinese version
Chinese version, very easy to use
Zend Studio 13.0.1
Powerful PHP integrated development environment
Dreamweaver CS6
Visual web development tools
SublimeText3 Mac version
God-level code editing software (SublimeText3)
Hot Topics
How to solve the problem that activex components cannot create objects
Jan 24, 2024 pm 02:48 PM
Solution: 1. Check spelling and path; 2. Add reference to component; 3. Check registry; 4. Run as administrator; 5. Update or repair Office; 6. Check security software; 7. Use other versions Components; 8. View error messages; 9. Find other solutions. Detailed introduction: 1. Check spelling and path: Make sure there are no spelling errors in the name and path of the object, and the file does exist in the specified path; 2. Add references to components, etc.
An in-depth analysis of the Java factory pattern: distinguishing and applying the differences between simple factories, factory methods and abstract factories
Dec 28, 2023 pm 03:09 PM
Detailed explanation of Java Factory Pattern: Understand the differences and application scenarios of simple factories, factory methods and abstract factories Introduction In the software development process, when faced with complex object creation and initialization processes, we often need to use the factory pattern to solve this problem. As a commonly used object-oriented programming language, Java provides a variety of factory pattern implementations. This article will introduce in detail the three common implementation methods of the Java factory pattern: simple factory, factory method and abstract factory, and conduct an in-depth analysis of their differences and application scenarios. one,
Constructor in Python
Sep 02, 2023 pm 04:29 PM
In Python, every class has a constructor, which is a special method specified inside the class. The constructor/initializer will be called automatically when a new object is created for the class. When an object is initialized, the constructor assigns values to data members in the class. There is no need to define the constructor explicitly. But in order to create a constructor, we need to follow the following rules - For a class, it is allowed to have only one constructor. The constructor name must be __init__. Constructors must be defined using instance properties (just specify the self keyword as the first argument). It cannot return any value except None. Syntax classA():def__init__(self):pass Example Consider the following example and
How to create objects using Java reflection mechanism?
Apr 15, 2024 pm 04:18 PM
The steps to create an object through the Java reflection mechanism are as follows: Load the target class: Use the Class.forName() method. Get the constructor: use the getDeclaredConstructor() method. Create an object: Use the newInstance() method to pass parameters.
C++ syntax error: The same constructor signature appears multiple times, how to solve it?
Aug 22, 2023 pm 04:49 PM
C++ is a powerful programming language, but it is inevitable to encounter various problems during use. Among them, the same constructor signature appearing multiple times is a common syntax error. This article explains the causes and solutions to this error. 1. Cause of the error In C++, the constructor is used to initialize the data members of the object when creating the object. However, if the same constructor signature is defined in the same class (that is, the parameter types and order are the same), the compiler cannot determine which constructor to call, causing a compilation error. For example,
Analysis of Java Factory Pattern: Evaluate the advantages, disadvantages and scope of application of three implementation methods
Dec 28, 2023 pm 06:32 PM
Exploring the Java Factory Pattern: Detailed explanation of the advantages, disadvantages and applicable scenarios of the three implementation methods Introduction: In the process of software development, we often encounter problems with object creation and management. In order to solve this problem, the factory pattern in design patterns came into being. Factory pattern is a creational design pattern that separates the creation and use of objects by encapsulating the object creation process in factory classes. There are three common ways to implement the factory pattern in Java: simple factory pattern, factory method pattern and abstract factory pattern. This article will explain these three implementations in detail
Does go language have constructors?
Jan 10, 2023 pm 02:15 PM
Go language does not have constructors. Go language, as a structured language, does not have constructors in object-oriented languages. However, similar effects of constructors in object-oriented languages can be achieved in some ways, that is, using the process of structure initialization to simulate the implementation of constructors.
C++ syntax error: The constructor defined outside the class must be added with the class name as a qualifier. How should it be corrected?
Aug 22, 2023 pm 02:00 PM
C++ is a widely used object-oriented programming language. When defining the constructor of a class in C++, if you want to place the definition of the constructor outside the class, you need to add the class name as a qualifier to the definition of the constructor. To specify which class this constructor belongs to. This is a basic rule of C++ syntax. If this rule is not followed when defining the constructor of a class, a compilation error will appear, prompting "Constructors defined outside the class must be qualified with the class name." So, if you encounter this kind of compilation error, you should
