通过实例理解javascript 的call()与apply()

01

function

print(a,
b, c, d){

02

alert(a
+ b + c + d);

03

}

04

function

example(a,
b , c , d){

05

//用call方式借用print,参数显式打散传递

06

print.call(

this

,
a, b, c, d);

07

//用apply方式借用print,
参数作为一个数组传递,

08

//这里直接用JavaScript方法内本身有的arguments数组

09

print.apply(

this

,
arguments);

10

//或者封装成数组

11

print.apply(

this

,
[a, b, c, d]);

12

}

13

//下面将显示”背光脚本”

14

example(”背”
, “光” , “脚”, “本”);

1

//例

2

print.call(window,
“背” , “光” , “脚”, “本”);

3

//foo参数可能为多个

4

function

foo(){

5

print.apply(window,
arguments);

6

}

/**
* Constructor: OpenLayers.Class
* Base class used to construct all other classes. Includes support for
*     multiple inheritance.
*
* This constructor is new in OpenLayers 2.5.  At OpenLayers 3.0, the old
*     syntax for creating classes and dealing with inheritance
*     will be removed.
*
* To create a new OpenLayers-style class, use the following syntax:
* (code)
*     var MyClass = OpenLayers.Class(prototype);
* (end)
*
* To create a new OpenLayers-style class with multiple inheritance, use the
*     following syntax:
* (code)
*     var MyClass = OpenLayers.Class(Class1, Class2, prototype);
* (end)
*
* Note that instanceof reflection will only reveal Class1 as superclass.
*
*/
OpenLayers.Class = function() {
var len = arguments.length;
var P = arguments[0];
var F = arguments[len-1];

var C = typeof F.initialize == "function" ?
F.initialize :
function(){ P.prototype.initialize.apply(this, arguments); };

if (len > 1) {
var newArgs = [C, P].concat(
Array.prototype.slice.call(arguments).slice(1, len-1), F);
OpenLayers.inherit.apply(null, newArgs);
} else {
C.prototype = F;
}
return C;
};

/**
* Property: isPrototype
* *Deprecated*.  This is no longer needed and will be removed at 3.0.
*/
OpenLayers.Class.isPrototype = function () {};

/**
* APIFunction: OpenLayers.create
* *Deprecated*.  Old method to create an OpenLayers style class.  Use the
*     <OpenLayers.Class> constructor instead.
*
* Returns:
* An OpenLayers class
*/
OpenLayers.Class.create = function() {
return function() {
if (arguments && arguments[0] != OpenLayers.Class.isPrototype) {
this.initialize.apply(this, arguments);
}
};
};

/**
* APIFunction: inherit
* *Deprecated*.  Old method to inherit from one or more OpenLayers style
*     classes.  Use the <OpenLayers.Class> constructor instead.
*
* Parameters:
* class - One or more classes can be provided as arguments
*
* Returns:
* An object prototype
*/
OpenLayers.Class.inherit = function (P) {
var C = function() {
P.call(this);
};
var newArgs = [C].concat(Array.prototype.slice.call(arguments));
OpenLayers.inherit.apply(null, newArgs);
return C.prototype;
};

/**
* Function: OpenLayers.inherit
*
* Parameters:
* C - {Object} the class that inherits
* P - {Object} the superclass to inherit from
*
* In addition to the mandatory C and P parameters, an arbitrary number of
* objects can be passed, which will extend C.
*/
OpenLayers.inherit = function(C, P) {
var F = function() {};
F.prototype = P.prototype;
C.prototype = new F;
var i, l, o;
for(i=2, l=arguments.length; i<l; i++) {
o = arguments[i];
if(typeof o === "function") {
o = o.prototype;
}
OpenLayers.Util.extend(C.prototype, o);
}
};

/**
* APIFunction: extend
* Copy all properties of a source object to a destination object.  Modifies
*     the passed in destination object.  Any properties on the source object
*     that are set to undefined will not be (re)set on the destination object.
*
* Parameters:
* destination - {Object} The object that will be modified
* source - {Object} The object with properties to be set on the destination
*
* Returns:
* {Object} The destination object.
*/
OpenLayers.Util = OpenLayers.Util || {};
OpenLayers.Util.extend = function(destination, source) {
destination = destination || {};
if (source) {
for (var property in source) {
var value = source[property];
if (value !== undefined) {
destination[property] = value;
}
}

/**
* IE doesn't include the toString property when iterating over an object's
* properties with the for(property in object) syntax.  Explicitly check if
* the source has its own toString property.
*/

/*
* FF/Windows < 2.0.0.13 reports "Illegal operation on WrappedNative
* prototype object" when calling hawOwnProperty if the source object
* is an instance of window.Event.
*/

var sourceIsEvt = typeof window.Event == "function"
&& source instanceof window.Event;

if (!sourceIsEvt
&& source.hasOwnProperty && source.hasOwnProperty("toString")) {
destination.toString = source.toString;
}
}
return destination;
};