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

Title:

Copy code The code is as follows:

try{
var me = Man( { fullname: "小红" });
var she = new Man({ fullname: "小红" });
console.group();
console.info("My name is :" me.attr("fullname") "nMy gender is:" me.attr("gender"));
console.groupEnd();
/*------[Execute Result]------
My name is: Xiaohong
My gender is:
-------------- ----*/
me.attr("fullname", "Xiao Ming");
me.attr("gender", "male");
me.fullname = "waste";
me.gender = "shemale";
she.attr("gender", "female");
console.group();
console.info("My name is:" me.attr("fullname") "nMy gender is:" me.attr("gender"));
console.groupEnd();
/*------[Execution Result] ------
My name is: Xiao Ming
My gender is: Male
------------------*/
console.group();
console.info("My name is:" she.attr("fullname") "nMy gender is:" she.attr("gender"));
console .groupEnd();
/*------[Execution Result]------
My name is: Xiaohong
My gender is: Female
-- ----------------*/
me.attr({
"words-limit": 3,
"words-emote": "smile"
});
me.words("I like watching videos.");
me.words("Our office is so beautiful.");
me.words("The beautiful women in the video So many! ");
me.words("I usually watch Youku! ");
console.group();
console.log(me.say());
/*------[Execution Result]------
Xiao Ming smiled: "I like watching videos. Our office is so beautiful. There are so many beauties in the video! "
------------------*/
me.attr({
"words-limit": 2,
"words-emote ": "Shout"
});
console.log(me.say());
console.groupEnd();
/*------[Execution Result]- -----
Xiao Ming shouted: "I like watching videos. Our office is so beautiful. "
------------------*/
}catch(e){
console.error("Execution error, error message: " e) ;
}

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 of creating objects in JS:
(a) Factory pattern: Use functions to encapsulate the details of creating objects with a specific interface.
Function createPerson(name, age, job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job ;
　　　　 o.sayName = function(){
　　　　　　　　　　　　};　　9 , "Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");
Disadvantages: Although the factory pattern solves the problem of creating multiple familiar objects, it does not solve the problem of object recognition. The problem (that is, how to know the type of an object).
　 (b) Constructor pattern: 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){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function() {
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 around through in new Person(“Nicholas”, 29, “Software Engineer”); "Greg", 27, "Doctor");
Disadvantages: The main problem with using constructors is that each method must be recreated on each instance. Don't forget - functions in ECMAScript are objects, so every time you define a function,
　, you instantiate an object.
　(c) Prototype pattern: Every function we create has a prototype attribute, which is a pointer pointing to an object, and the purpose of this object is to contain all the objects that can be represented by a specific type
Properties and methods shared by instances. The advantage of using a prototype object is that all objects can share the properties and methods it contains.
function Person(){
= 29;
　　Person.prototype.job = “Software Engineer”; = new Person();
　　person1.sayName(); //"Nicholas"
　var person2 = new Person();
　　person2.sayName(); //"Nicholas"
　alert( person1.sayName == person2.sayName); //true
Disadvantages: All properties in the prototype are shared by many instances. This kind of sharing is very suitable for functions. But for properties with reference type values, the problem is more prominent.
　(d) Combined use of constructor pattern and prototype pattern: The most common way to create a custom type is to use combined use of constructor pattern and prototype pattern. Constructor pattern is used to define instance properties, while prototype pattern is used to define methods and shared properties.
Function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.friends = ["Shelby ", "Court"];
　　　}
　　Person.prototype = {
　　　constructor: Person,
　　　sayName: function () {
　　　　alert(this.name);
　　　　}
　　};
　　var person1 = new Person(“Nicholas”, 29, “Software Engineer”);
　　var person2 = new Person(“Greg”, 27, “Doctor”);
　　person1. friends.push(“Van”);
alert(person1.friends); //”Shelby,Court,Van”
alert(person2.friends); //”Shelby,Court”
alert( person1.friends === person2.friends); //false
　alert(person1.sayName === person2.sayName); //true
Answer:




Copy code


The code is as follows: