The code is as follows:
<script type="text/javascript">
var People = {
name: "kym",
age: 21,
SayHello: function () {
alert("Hello,My name is " + + ".I am " + );
}
}
alert();
();
</script>
But we cannot reuse this object. How do we use this object as a prototype?
First of all, it is impossible to have a constructor method in a JSON object, so let’s build a simple “factory” and write a method to be specifically responsible for the creation.
<script type="text/javascript">
var People = {
Create: function (name, age) {
= name;
= age;
},
SayHello: function () {
alert("Hello,My name is " + + ".I am " + );
}
}
("kym", 21);
();
</script>
But through this method, we found that we have no way to use People as a prototype. Let’s review: Javascript Learning Notes 7 - Principle of Prototype Chain In this article, let’s think about this process:
var p=new People();==>p.__proto__=. So when we () we will go to the middle and find nothing.
If you can =function(){}, you can solve this problem. But we know that only function can have prototype.
So let’s think about the previous derivation formula, how can we make ()? It would be great if you could p.__proto__=People. Then let's think of a solution:
Since when new, the __proto__ of an object can only be equal to the prototype of a certain function, we set a function X, let p.__proto__=, and then let =People. This relationship is like this:
<script type="text/javascript">
var People = {
Create: function (name, age) {
= name;
= age;
},
SayHello: function () {
alert("Hello,My name is " + + ".I am " + );
}
};
var X = function () { };
= People;
var p = new X();
("kym", 21);
();
</script>
This is equivalent to using X as an intermediate variable, allowing us to access the internal properties of the JSON object. But isn't this not very elegant? Every time we create an object, we need to write such a helper function. Well, let's encapsulate this process:
var Factory = {
CreatePeople : function (className,name,age) {
var temp = function () {
(name, age);
};
= className;
var result = new temp();
return result;
}
};
var people = (People,"kym",21);
();
But this also has a disadvantage, that is, every time I add a class, I need to register a new method to the Factory, which is very troublesome. I mentioned the difference between call and apply in the play method: call and apply a long time ago. Because the parameters here are not fixed, we cannot list them one by one, so we can use apply to improve this method here:
<script type="text/javascript">
var People = {
Create: function (name, age) {
= name;
= age;
},
SayHello: function () {
alert("Hello,My name is " + + ".I am " + );
}
};
var Factory = {
Create: function (className, params) {
var temp = function () {
(this, params);
};
= className;
var result = new temp();
return result;
}
};
var people = (People,["kym",21]);
();
</script>
In this way, a complete creation class is born! Then we can use JSON every time we create a "class", and then the user calls() in a unified way every time!
Copy the codeThe code is as follows:
<script type="text/javascript">
var People = {
name: "kym",
age: 21,
SayHello: function () {
alert("Hello,My name is " + + ".I am " + );
}
}
alert();
();
</script>
But we cannot reuse this object. How do we use this object as a prototype?
First of all, it is impossible to have a constructor method in a JSON object, so let’s build a simple “factory” and write a method to be specifically responsible for the creation.
Copy the codeThe code is as follows:
<script type="text/javascript">
var People = {
Create: function (name, age) {
= name;
= age;
},
SayHello: function () {
alert("Hello,My name is " + + ".I am " + );
}
}
("kym", 21);
();
</script>
But through this method, we found that we have no way to use People as a prototype. Let’s review: Javascript Learning Notes 7 - Principle of Prototype Chain In this article, let’s think about this process:
var p=new People();==>p.__proto__=. So when we () we will go to the middle and find nothing.
If you can =function(){}, you can solve this problem. But we know that only function can have prototype.
So let’s think about the previous derivation formula, how can we make ()? It would be great if you could p.__proto__=People. Then let's think of a solution:
Since when new, the __proto__ of an object can only be equal to the prototype of a certain function, we set a function X, let p.__proto__=, and then let =People. This relationship is like this:
Copy the codeThe code is as follows:
<script type="text/javascript">
var People = {
Create: function (name, age) {
= name;
= age;
},
SayHello: function () {
alert("Hello,My name is " + + ".I am " + );
}
};
var X = function () { };
= People;
var p = new X();
("kym", 21);
();
</script>
This is equivalent to using X as an intermediate variable, allowing us to access the internal properties of the JSON object. But isn't this not very elegant? Every time we create an object, we need to write such a helper function. Well, let's encapsulate this process:
Copy the codeThe code is as follows:
var Factory = {
CreatePeople : function (className,name,age) {
var temp = function () {
(name, age);
};
= className;
var result = new temp();
return result;
}
};
var people = (People,"kym",21);
();
But this also has a disadvantage, that is, every time I add a class, I need to register a new method to the Factory, which is very troublesome. I mentioned the difference between call and apply in the play method: call and apply a long time ago. Because the parameters here are not fixed, we cannot list them one by one, so we can use apply to improve this method here:
Copy the codeThe code is as follows:
<script type="text/javascript">
var People = {
Create: function (name, age) {
= name;
= age;
},
SayHello: function () {
alert("Hello,My name is " + + ".I am " + );
}
};
var Factory = {
Create: function (className, params) {
var temp = function () {
(this, params);
};
= className;
var result = new temp();
return result;
}
};
var people = (People,["kym",21]);
();
</script>
In this way, a complete creation class is born! Then we can use JSON every time we create a "class", and then the user calls() in a unified way every time!