1. Use of basic classes
Method 1:
The code copy is as follows:
function sth(a) // constructor function
{
this.a = a;
this.fun = output; // member function
}
function output(a, b, c)
{
document.write(this.a);
}
//Call
var s = new sth(250);
s.fun(1, 2, 3);
ouput(1, 2, 3); //If output is wrong before sth
Method 2:
Copy the code as follows: function sth(a)
{
this.a = a;
this.output = function()
{
document.write(this.a);
}
}
var s = new sth(2);
s.output(); // Output 2
2. Inheritance
Method 1:
Copy the code as follows: function A(x)
{
this.x = x;
}
function B(x, y)
{
// Method 1
/*
this.construct = A;
this.construct(x);
delete this.construct;
*/
// Method 2
//A.call(this, x);
// Method 3
A.apply(this, new Array(x)); // It can also be A.apply(this, arguments), but the argument parameter order must be correct
this.y = y;
this.print = function()
{
document.write("x = ", x,
", y = ", y);
}
}
var b = new B(1, 2);
b.print();
alert(B instanceof A); // Output false
Advantages: Multiple inheritance can be achieved (just call multiple calls)
shortcoming:
・ Must be used as a constructor
・Use the instanceof operator to operate this inheritance result to false
Method 2:
Copy the code as follows: function A()
{
}
A.prototype.x = 1;
function B()
{
}
B.prototype = new A(); // Cannot take parameters!
B.prototype.y = 2;
B.prototype.print = function()
{
document.write(this.x, ", ", this.y, "<br>");
}
var b = new B();
b.print();
document.write(b instanceof A); // Output true
shortcoming:
・ Cannot achieve multiple inheritance
・ The constructor does not have parameters
Tips
Usually using a hybrid mode, both
The code copy is as follows:
function A(x)
{
this.x = x;
}
A.prototype.printx = function() // Write this.printx = function.... It is also possible, the same below
{
document.write(this.x, "<br>");
}
function B(x, y)
{
A.call(this, x);
this.y = y;
}
B.prototype = new A(); // Cannot take parameters!
B.prototype.printxy = function()
{
document.write(this.x, ", ", this.y, "<br>");
}
var b = new B(1, 2);
b.printx(); // Output 1
b.printxy(); // Output 1, 2
document.write(b instanceof A); // Output true
3. Use of static member functions
Copy the code as follows: function sth(a)
{
this.a = a;
}
sth.fun = function(s)
{
document.write(sa);
}
var s = new sth(2);
sth.fun(s); // Output 2
IV. Release of objects
Copy the code as follows: var obj = new Object; // obj is a reference
obj = null; // Dereference will automatically garbage collection; if you need to release this object at all, all its references must be assigned to null
V. Function Object
Copy the code as follows: var v = new Function("arg1", "arg2", "document.write(arg1 + arg2);"); // Define a function object with the parameters arg1 and arg2 respectively
v(1, 2); // will output 3
6. Callback function
Copy the code as follows: function callback(func, arg)
{
func(arg);
}
function fun(arg)
{
document.write(arg);
}
//callback(func, "sb"); // This method does not work
var func = new Function("arg", "fun(arg);");
// Of course, func(arg) can also be replaced with specific execution code.
// But if the function code is huge, it is better to do this
callback(func, "sb");
7. Function overloading
Copy the code as follows: function fun()
{
switch (arguments.length)
{
case 1:
document.write(arguments[0]);
break;
case 2:
document.write(arguments[0] + arguments[1]);
break;
default:
document.write("ERROR!");
break;
}
}
fun(1);
fun(1, 2);
8. Use function closure to implement functions with "static variables"
Copy the code as follows: function fun()
{
var v = 1;
function fun2()
{
++v;
document.write(v);
document.write("<br>");
return v;
}
return fun2;
}
var func = fun();
func(); // Output 2
func(); // Output 3
func(); // Output 4