Function

Function as constructor

Can create a new Function object dynamically, but suffers from security & some performance issues to 'eval'. Creates functions that execute in global scope only. Usage: new Function('arg1','arg2'..., '// function body code')

Defining

Normal declaration / expression: function name(p1, p2) { // statements} // name can be omitted in expression

Generator/generator expression: function* name(p1, p2) {// statements }

Arrow expression: (p1, p2) => {//statements} // note array function has no own 'this', 'arguments' and 'super', suitable for pure function and not suitable for methods and cannot be used for constructors

Constructors: new Function(..) see above, new GeneratorFunction(arg1, arg2, ... argN, functionBody)

Parameters

Normal ones: p1, p2, .... pN - missing parameters are passed 'undefined'

With default: (p1, p2='default',...) if received 'undefined' will use default to replace

Destruct syntax: ( { para1, para2})

• pass in "o", para1 / para2 points to o.para1, o.para2

Rest parameters: function sum(...theArgs) { // theArgs is passed as an array}

Available Objects inside Function Body (not array function)

arguments: array-like object containing arguments

arguments.length:

X arguments.callee: deprecated, the current executing function

X arguments.caller: deprecated

this:

• when called as method, refer to the object

About "this"

A method itself is just a function not bound (no "this").

When called with an object in syntax "someObject.someMethod", "this" is bound - to "someObject"

Therefore, (IMPORTANT) a method can be passed as a callback - but when caller calls the method without binding something (caller just views it as a function), "this" will be missing! So if a callback needs to access "this", use "this.someMethod.bind(this)"

Properties

Properties attached to Function.prototype

arguments: deprecated, use 'arguments' object within function body instead

arity: deprecated

caller: not standard and not on track

length: number of expected arguments

name: function name

Function.displayName: not standard

Function.prototype.constructor: ??? just don't know what's the use of this

Methods

These are Function.prototype properties...

apply(thisObject, [arg1, arg2, arg3]) - pass in 'this' object and the arguments, and invoke the function

call(thisObject, arg1, arg2, arg3...) - different in 'apply' in accepting an argument list while 'apply' accepting a single array of arguments

bind(thisObject, arg1, arg2...) - returns a new 'bind function' that when called, call the original function with 'thisObject' as 'this' and also arg1, arg2...., and any arguments given to the 'bind function' will follow

isGenerator() - note: has not been standardized

toSource() - has not been standardized

toString() - returns a string representation of the source code

Closure

• Function-local scopes (parameters & local variables) are re-created every time a function is called
  • if the value is referred to after exit of function they still can be accessed (closure)
  • value is not "freezed", just a reference is kept

Pure Function

• functions are called for
  • side effect (console.log)
  • return value - easier to combine when no side effect
  • pure function
    • no side effect
    • does not rely on side effect (no read from global variables)
    • only rely from parameter

Generator function

Can be exited and later re-entered, context preserved

• function* generator(i) { yield i; yield i+10;}
• Especially for combination with promises for asynchronous programming
• Calling generator function does not execute it immediately, but returns an iterator object
• When iterator object's next() is called, the generator function's body is called until first
  • 'yield' expression, or
  • 'yield* ' expression delegates to another generator function,
  • return : finish generator (returned object with done property to be true)
• return from next(): an object with 'value' and 'done' - whether this is the last.
• next(with_argument) : resume function, replacing yield expression with argument