Function : Object

Functions are reusable pieces of code that can be executed with

different parameters.

Spec:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.3

----

Function([param1 : String, [param2 : String, [...]]], body : String) : Function

Same as %%#new_Function_String_String_dotdotdot_String|**new Function(param1, param2, ..., body)**%%.

Spec:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.1.1

----

new Function([param1 : String, [param2 : String, [...]]], body : String) : Function

<p>Creates a new normal **Function** that has the supplied parameter names and body.

If any parameter name contains a **','**, it will be split on the **','** and

each component will be added as a parameter. Unless the **body** needs to

be modified at run time, **Function**s are typically created with the

**function** keyword.</p>

<p>See example below on how to construct generator (**function*()**) and async

functions (**async function()**).</p>

<example>

// The following result in equivalent behavior, but the first

// should be used unless the body changes at run time.

var f1 = function(x, y) { return x + y; };

var f2 = Function('x', 'y','return x + y;');

var f3 = Function('x, y', 'return x + y;');

var f4 = new Function('x', 'y', 'return x + y;');

// The following demonstrate creating generator and async functions

var GeneratorFunction = Object.getPrototypeOf(function*(){}).constructor;

// The following are equivalent:

var g1 = function*(x, y) { yield x; yield y; }

var g2 = GeneratorFunction('x', 'y', 'yield x; yield y;');

var g3 = new GeneratorFunction('x, y', 'yield x; yield y;');

var AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;

// The following are equivalent:

var a1 = async function(url) { return (await fetch(url)).status; }

var a2 = AsyncFunction('url', 'return (await fetch(url)).status;');

var a3 = new AsyncFunction('url', 'return (await fetch(url)).status;');

var AsyncGeneratorFunction = Object.getPrototypeOf(async function*(){}).constructor;

// The following are equivalent:

var ag1 = async function*(x, y) { yield await x; yield await y; }

var ag2 = AsyncGeneratorFunction('x', 'y', 'yield await x; yield await y;');

var ag3 = new AsyncGeneratorFunction('x, y', 'yield await x; yield await y;');

</example>

Spec:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.2.1

----

prototype.apply([thisArg : Object, [parameters : Array]]) : Object

Call **this** with the **this** value inside the function bound to **thisArg**

and the parameters to the function from **parameters**. Returns the result

of the function call. See %%/Reflect.apply|Reflect.apply()%%.

<example>

var whatsThis = function() { console.log(this); }

whatsThis.apply('hello');

// Call a function that takes a variable number of args

var numbers = [3, 20, 1, 45];

console.log(Math.max.apply(undefined, numbers));

</example>

Spec:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.4.3

----

prototype.call([thisArg : Object, [param1 : Object, [param2 : Object, [...]]]]) : Object

Call **this** with the **this** value inside the function bound to **thisArg**

and parameters **(param1, param2, ...)**. Returns the result of the function call.

<example>

var whatsThis = function() { console.log(this); }

whatsThis.call('hello');

// Call a function that takes a variable number of args

console.log(Math.max.call(undefined, 3, 20, 1, 45));

</example>

Spec:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.4.4

----

prototype.bind(thisArg : Object, [param1 : Object, [param2 : Object, [...]]]) : Function

Returns a new function that, when called, will have **this** equal to **thisArg**,

the first parameter equal to **param1**, the second parameter equal to **param2**,

etc.

<example>

var Button = function(content) {

this.content = content;

};

Button.prototype.click = function() {

console.log(this.content + ' clicked');

}

var myButton = new Button('OK');

myButton.click();

var looseClick = myButton.click;

looseClick();

var boundClick = myButton.click.bind(myButton);

boundClick();

// Example showing binding some parameters

var sum = function(a, b) {

return a + b;

};

var add5 = sum.bind(null, 5);

console.log(add5(10));

</example>

Spec:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.4.5

----

instance.length : Number

The number of parameters specified when the function was defined.

<example>

var add = function(x, y) { return x + y; };

console.log(add.length);

</example>

Spec:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5.1

----

instance.prototype : Object

The prototype for objects created by calling this function

with the **new** keyword.

<example>

var Button = function(content) {

this.content = content;

};

Button.prototype.click = function() {

console.log(this.content + ' clicked');

}

var myButton = new Button('OK');

myButton.click();

</example>

Spec:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5.2