| |
1. Basic Concepts
1.1 Prototype
Each function has a prototype (prototype) property that is a pointer to an object, and the object is to use all the forces of the class that contains the shared properties and methods.
No prototype way:
// Decimal point, tax rate
var decimalDigits = 2,
tax = 5;
function add (x, y) {
return x + y;
}
function subtract (x, y) {
return x - y;
}
// Alert (add (1, 3));
The first way:
var Calculator = function (decimalDigits, tax) {
this.decimalDigits = decimalDigits;
this.tax = tax;
};
Calculator.prototype = {
add: function (x, y) {
return x + y;
},
subtract: function (x, y) {
return x - y;
}
};
// Alert ((new Calculator ()) add (1, 3).);
The second way:
Calculator.prototype = function () {} ();
Calculator.prototype = function () {
add = function (x, y) {
return x + y;
},
subtract = function (x, y) {
return x - y;
}
return {
add: add,
subtract: subtract
}
} ();
// Alert ((new Calculator ()) add (11, 3).);
Of course, we can also step declaration
var BaseCalculator = function () {
// Declare a number of decimal places for each instance
this.decimalDigits = 2;
};
// Prototype to BaseCalculator extended two object methods
BaseCalculator.prototype.add = function (x, y) {
return x + y;
};
BaseCalculator.prototype.subtract = function (x, y) {
return x - y;
};
1.2 prototype chain
ECMAScript describes the concept of the prototype chain, and the prototype chain as the main method of implementation inheritance. The basic idea is to use the prototype to make a reference type inherits from another type of reference properties and methods. A brief review of the relationship between the constructor and prototype instance: Each constructor function has a prototype object, the prototype object contains a pointer to a pointer to the constructor, and contains a pointer to the actual prototype object's internal pointer. So if we make a prototype object is equal to another instance of the type, what will happen then? Obviously, at this time the prototype object will contain a pointer to a pointer to another prototype, correspondingly, another prototype also includes a pointer to a pointer to another constructor. If the prototype is another instance of another type, the above relationship is still valid, so progressive layers, and constitutes an example of the prototype chain. This is the basic concept of the so-called prototype chain.
function SuperType () {
this.property = true;
}
SuperType.prototype.getSuperValue = function () {
return this.property;
};
function SubType () {
this.subproperty = false;
}
SubType.prototype = newSuperType ();
SubType.prototype.getSubValue = function () {
return this.subproperty;
};
var instance = new SubType ();
alert (instance.getSuperValue ()); // true
2. The project combat
Roadside assistance in the project, when the operator every step of the operation carried out, must be recorded in the log table inside the case, to allow administrators to clearly see the operation process every step of the operation, in order not to repeat the development, need to make a case record tools JS: CaseLogUtil.js
Wherein, when we want to call this method when instantiated directly CaseLog, call its methods to log.
Example: var test = new CaseLog ( "11", "content");
test.log (); |
|
|
|