Learn Javascript object-oriented (create objects) from interview questions

topic:

Knowledge points:
(1) JS object-oriented basics: ECMA-262 defines an object as: "a collection of unordered attributes, whose attributes can contain basic values, objects or functions."
(2) Methods for creating objects in JS:
(a) Factory pattern: Use functions to encapsulate the details of creating objects with specific interfaces.
function createPerson(name, age, job){
var o = new Object();
= name;
= age;
= job;
= function(){
alert();
};
return o;
}
var person1 = createPerson(“Nicholas”, 29, “Software Engineer”);
var person2 = createPerson(“Greg”, 27, “Doctor”);
Disadvantages: Although the factory pattern solves the problem of creating multiple acquainted objects, it does not solve the problem of object recognition (i.e. how to know the type of an object).
(b) Constructor mode: Constructors in ECMAScript can be used to create objects of specific types. You can create custom constructors to define properties and methods of custom object types.
function Person(name, age, job){
= name;
= age;
= job;
= function(){
alert();
};
}
var person1 = new Person(“Nicholas”, 29, “Software Engineer”);
var person2 = new Person(“Greg”, 27, “Doctor”);
Disadvantages: The main problem with using constructors is that each method needs to be recreated on each instance. Don't forget - functions in ECMAScript are objects, so each function is defined,
It is to instantiate an object.
(c) Prototype pattern: Each function we create has a prototype property, which is a pointer, pointing to an object, and the purpose of this object is to contain a specific type that can be used by
All instances of shared properties and methods. The advantage of using a prototype object is that it allows all objects to share the properties and methods it contains
function Person(){
}
= “Nicholas”;
= 29;
= “Software Engineer”;
= function(){
alert();
};
var person1 = new Person();
(); //”Nicholas”
var person2 = new Person();
(); //”Nicholas”
alert( == ); //true
Disadvantages: All properties in the prototype are shared by many instances, and this sharing is very suitable for functions. However, for attributes that reference type values, the problem is more prominent.
(d) Combination of constructor patterns and prototype patterns: The most common way to create custom types is to use combination of constructor patterns and prototype patterns. The constructor mode is used to define instance properties.
And the prototype pattern is used to define methods and shared properties.
function Person(name, age, job){
= name;
= age;
= job;
= [“Shelby”, “Court”];
}
= {
constructor: Person,
sayName : function () {
alert();
}
};
var person1 = new Person(“Nicholas”, 29, “Software Engineer”);
var person2 = new Person(“Greg”, 27, “Doctor”);
(“Van”);
alert(); //”Shelby,Court,Van”
alert(); //”Shelby,Court”
alert( === ); //false
alert( === ); //true
Answer: