The simplest of two ways to create objects
(1) var person=new Object ();
Person.name= "JXJ";
Person.age= "24";
Person.sayhi=function () {
Console.log ("My name is" + THIS.name + ", this year" + This.age + "years old");
}.......
(2) var person={
Name: "Jxj",
Age: "24",
Sayhi:function () {
Console.log ("My name is" + THIS.name + ", this year" + This.age + "years old");
}
}
Factory mode
function Createperson (name, age) {
var o = new Object ();
O.name = name;
O.age = age;
O.sayhi = function () {
Console.log ("My name is" + THIS.name + ", this year" + This.age + "years old");
};
}
var p1 = new Createperson ("Jxj", "24");
var p1 = new Createperson ("Jxj", "25");
Objects built on the accepted parameters
Problem, object recognition----objects that are returned are of type object (if Createcar (),, Car1, Car2, p1, p2 are ojbect types)
typeof P1; Returns "Object";
P1 instanceof Object//returns True
Object.prototype.toString.call (p1); Returns "[Object Object]"
constructor function
function person (name, age) {
THIS.name = name;
This.age = age;
This.sayhi = function () {
Console.log ("My name is" + THIS.name + ", this year" + This.age + "years old")
};
This.saybye = function () {
Console.log ("Saybye")
};
}
var jxj = new Person ("JXJ", "24");
var jxj2 = new Person ("jxj2", "25");
Successfully solve object recognition problems
JXJ instanceof person//return True
JXJ instanceof Object//Returns True, all objects are inherited from Object
Problem:
/each formation is unique to a property and method, but actually in the application of the method, a method to complete the same function, there is no need to have a single copy of the instance (each method is an object);
function person (name, age) {
THIS.name = name;
This.age = age;
This.sayhi = Sayhi;
This.saybye = Saybye;
}
function Sayhi () {
Console.log ("My name is" + THIS.name + ", this year" + This.age + "years old")
};
function Saybye () {
Console.log ("Saybye")
};
Problem:
Mount global scope, define multiple methods to define multiple global functions
No encapsulation
Expansion: The difference between constructors and functions: Invocation mode
Use as a normal function
Person ("Jxj", "" "),//this points to the global window, attributes are added to the Window object
Window.name;
Window.sayhi ();
JS prototype mode
JS prototype object Knowledge (person Prototype prototype object, Prototype attribute, [Prototype],constructor)
JS creates a function (including normal functions, and constructors, function expressions), creates a prototype property, and points to the prototype object of the function;
Each object (the pointer to the prototype object points to an object Prototype prototype object) uses a [Prototype] pointer to the prototype object
Person.prototype.isPrototypeOf (JXJ);//Returns True
Object.getprototypeof (JXJ) ==person.prototype;//returns True
function hehe () {}
Object.getprototypeof (Hehe.prototype);//object {}
var a=new hehe ();
Hehe.prototype.isPrototypeOf (a);//true
Object.prototype.isPrototypeOf (hehe.prototype);//true
After the constructor is created, its prototype object gets the constructor property by default, pointing to the constructor (person), (the object calls constructor are derived from its prototype object)
function person (name) {
THIS.name = name;
}
var p1 = new Person ("JXJ");
P1.constructor
P1.hasownproperty ("constructor") false
Person.prototype.hasOwnProperty ("constructor") True
P1.constructor = = = Person.prototype.constructor true
Person.prototype.isPrototypeOf (p1); true
Object.getprototypeof (person)
function Empty () {}
Function.prototype.isPrototypeOf (person) True
Object.getprototypeof (p1)
person {} object.getprototypeof (person)
function Empty () {}
(1) Person.prototype, Mount Properties and methods
function person () {}
Person.prototype.name = "JXJ";
Person.prototype.age = "24";
Person.prototype.sayHi = function () {
Console.log ("My name is" + THIS.name + ", this year" + This.age + "years old")
};
var jxj = new Person ();
var jxj2 = new Person ();
(2) object literal, overriding the entire prototype object
function person () {} Person.prototype = {
//constructor:person
Name: "Jxj",
Age: "24",
Friend: {"AAA", "BBB", "CCC"},
Sayhi:function () {
Console.log ("My name is" + THIS.name + ", this year" + This.age + "years old")
};
}
var jxj = new Person ();
var jxj2 = new Person ();
JXJ instanceof Person;//true;
Jxj.constructor==person;//false; In fact, constructor already points to the object constructor
All instances share a copy of the attribute
Jxj.friend.push ("ddd");
jxj.friend===jxj2.friend;//returns true,{"AAA", "BBB", "CCC", "ddd"};
Combining the constructor pattern with the prototype pattern (most commonly used mode)
function person (name, age) {
THIS.name = name;
This.age = age;
Friend: {"AAA", "BBB", "CCC"};
This.sayhi = function () {
Console.log ("My name is" + THIS.name + ", this year" + This.age + "years old")
};
person.prototype={
Constructor:person,
Sayhi:function () {
Console.log ("My name is" + THIS.name + ", this year" + This.age + "years old")
},
This.saybye = function () {
Console.log ("Saybye")
}
}
A constructor pattern that defines the properties of an instance;
Prototype patterns are used for definitions, methods, and properties that you want to share
Inherit---(The principle uses the prototype chain to make the prototype object equal to another instance of the type)
Father
function Father () {
this.fatherheight= "1.75";
}
Father.prototype.getfatherheight=function () {
Console.log (This.fatherheight);
}
Child
function Child () {
This.childheight= "1.20";
}
Subclass Inherits Parent Class
Child.prototype=new Father ();
Child.prototype.getheight=function () {
Console.log (This.childheight);
}
var c=new child ();
C.getfatherheight ();
This article is from the "7439523" blog, please be sure to keep this source http://7449523.blog.51cto.com/7439523/1564964
JavaScript Object-oriented and prototype