Master of JavaScript Advanced Learning Notes

The use of basic classes

Method One

function Sth (a)//constructor
{
THIS.A = A;
This.fun = output; member functions
}

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 Two

function Sth (a)
{
THIS.A = A;

This.output = function ()

{
document.write (THIS.A);
}
}

var s = new Sth (2);

S.output (); Output 2

Inherited

Method One

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)); may also a.apply (this, arguments), but the arguments parameter order must be to

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

Benefits: Multiple inheritance can be implemented (call calls are good)

Disadvantages:

· Must be used as a constructor

· Using the instanceof operator, this class inherits the result to False

Method Two

function A ()

{

}

a.prototype.x = 1;

function B ()

{

}

B.prototype = new A (); Can't 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

Disadvantages:

· Cannot implement multiple inheritance

· constructor with no parameters

Tips

Blending mode is usually used, both

function A (x)
{

this.x = x;
}

A.prototype.printx = function ()//write to Class A this.printx = function .... is also possible, the same as
{

document.write (this.x, "<br>");
}


function B (x, y)
{
A.call (this, x);
This.y = y;

}

B.prototype = new A (); Can't 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

Use of similar static member functions

function Sth (a)
{
THIS.A = A;
}

Sth.fun = function (s)
{
document.write (S.A);
}

var s = new Sth (2);

Sth.fun (s); Output 2

object's release

var obj = new Object; obj is a reference

obj = null; Dereference, garbage collection is done automatically, and if you need to dispose of this object at all, assign all its references to null

Function object

var v = new Function ("Arg1", "arg2", "document.write (Arg1 + arg2);"); Defines a function object, which is ARG1,ARG2

V (1, 2); Will output 3


callback function

function callback (func, Arg)
{
Func (ARG);
}

function Fun (ARG)
{
document.write (ARG);
}


Callback (func, "SB"); That's not going to work.

var func = new Function ("Arg", "Fun (ARG);");
Of course, you can also change func (ARG) into specific execution code,
But the function code is huge, and that's the best thing to do.

Callback (func, "SB");

Overload of a function

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);


Using function closures to implement functions with "static variables"

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