javascript prototype prototype operation notes_javascript skills

Copy code The code is as follows:

//var People={name:"xiong",age:15 };
//var Person=function(user,age){
// this.name=user;
// this.age=age;
// this.say=function( ){alert("I am " this.name "n" this.age);}
//}
//var Chairman=function(name,salary){
// Person.call( this,name);
// }
//var Bill=new Person("Bill",15);
//var Hu=new Chairman("Hu Jintao");
/ /Person.prototype.eat=function(){
// alert("I'm eating");
// }
//Bill.eat();
function Person(name ) //Base class constructor
{
this.name = name;
};

Person.prototype.SayHello = function() //Add to the prototype of the base class constructor Method
{
alert("Hello, I'm " this.name);
};

function Employee(name, salary) //Subclass constructor
{
Person.call(this, name); //Call the base class constructor
this.salary = salary;
};

function Xiong(name,age){
Employee.call(this,name);

   }

Employee.prototype = new Person(); //Create a base class object as the prototype of the subclass prototype. This is very interesting

Xiong.prototype=new Employee();

Employee.prototype.ShowMeTheMoney = function() //Add the prototype of the constructor to the subclass and add a method
{
alert( this.name " $" this.salary);
};
var BillGates = new Person("Bill Gates"); //Create a BillGates object of base class Person
var SteveJobs = new Employee(" Steve Jobs", 1234); //Create SteveJobs object of subclass Employee
var hiakuotiankong=new Xiong("Broad Sky");
var benbenxiong=new Xiong("Stupid Bear");

// BillGates.SayHello(); // Directly call the prototype method through the object
// hiakuotiankong.SayHello(); // Directly call the base class prototype method through the subclass object, pay attention!
benbenxiong.SayHello=function(){ //Hide the prototype SayHello method
alert("haha,I'm" this.name);
}
benbenxiong.SayHello();
// SteveJobs.ShowMeTheMoney(); // Directly call the subclass prototype method through the subclass object
// alert(BillGates.SayHello == SteveJobs.SayHello); // Display: true, indicating the prototype method It is shared
Xiong.prototype.Goodbye=function(){
alert(this.name "Bye-bye");
benbenxiong.Goodbye();

In JavaScript, prototypes not only allow objects to share their wealth, but prototypes also have the
nature of tracing their roots and ancestors, so that the legacy of our ancestors can be passed down from generation to generation. When reading attributes or calling methods from an object, if the object itself
does not have such an attribute or method, it will look for it in its associated prototype object; if the prototype does not have it, it will
go there again. The prototype's associated predecessor prototypes are searched there until they are found or the tracing process ends.

In JavaScript, the property and method tracing mechanism of objects is implemented through the so-called prototype chain. When the new
operator is used to construct an object, the prototype object of the constructor will also be assigned to the newly created object and become the built-in prototype
object of the object. The object's built-in prototype object should be invisible to the outside world. Although some browsers (such as Firefox) can allow us to access this
built-in prototype object, it is not recommended. The built-in prototype object itself is also an object and has its own associated prototype object, thus
forming a so-called prototype chain.

At the end of the prototype chain, it is the prototype object pointed to by the prototype property of the Object constructor. This prototype object
is the oldest ancestor of all objects. This ancestor implements methods such as toString that all objects should inherently have. Other built-in
constructors, such as Function, Boolean, String, Date and RegExp prototypes are all inherited from this ancestor
, but they each define their own properties and methods, so their The descendants showed those characteristics of their respective clans.