Brief Intro to Functions in JavaScript (Lesson 3)

Learning JavaScript as a Second Language
Functions in JavaScript
Four Parts of a Function

Function objects are created with function literals:
// Create a variable called add and store a function in it that adds two numbers.
var add = function (a, b) { return a + b; };

A function literal has four parts. 
The first part is the reserved word function. 
The optional second part is the function’s name. The function can use its name to call itself recursively. The name can also be used by debuggers and development tools to identify the function. If a function is not given a name, as shown in the previous example, it is said to be anonymous.
The third part is the set of parameters of the function, wrapped in parentheses. Within the parentheses is a set of zero or more parameter names, separated by commas. These names will be defined as variables in the function. Unlike ordinary variables, instead of being initialized to undefined, they will be initialized to the arguments supplied when the function is invoked.
The fourth part is a set of statements wrapped in curly braces. These statements are the body of the function. They are executed when the function is invoked.

Invocation

Invoking a function suspends the execution of the current function, passing control and parameters to the new function. In addition to the declared parameters, every function receives two additional parameters: this and arguments. The this parameter is very important in object oriented programming, and its value is determined by the invocation pattern. 
There are four patterns of invocation in JavaScript: 
1. the method invocation pattern, 
2. the function invocation pattern, 
3. the constructor invocation pattern, and 
4. the apply invocation pattern. 

The patterns differ in how the bonus parameter “this” is initialized. The invocation operator is a pair of parentheses that follow any expression that produces a function value. The parentheses can contain zero or more expressions, separated by commas. Each expression produces one argument value. Each of the argument values will be assigned to the function’s parameter names. There is no runtime error when the number of arguments and the number of parameters do not match. If there are too many argument values, the extra argument values will be ignored. If there are too few argument values, the undefined value will be substituted for the missing values. There is no type checking on the argument values: any type of value can be passed to any parameter.

Out of these four patterns, "Method Invocation Pattern" and "Constructor Invocation Pattern" are important in understanding and working with KnockoutJS.

The Method Invocation Pattern

When a function is stored as a property of an object, we call it a method. When a method is invoked, “this” variable is bound to that object. If an invocation expression contains a refinement (that is, a . dot expression or [subscript] expression), it is invoked as a method:
// Create myObject. It has a value and an increment method. The increment method takes an optional parameter. If the argument is not a number, then 1 is used as the default.


var myObject = {
  value: 0,
  increment: function (inc) {
  this.value += typeof inc === 'number' ? inc : 1;
} };

myObject.increment( ); 
document.writeln(myObject.value); // 1

myObject.increment(2); 
document.writeln(myObject.value); // 3 

A method can use this to access the object so that it can retrieve values from the object or modify the object. The binding of this to the object happens at invocation time. This very late binding makes functions that use this highly reusable. Methods that get their object context from this are called public methods.

The Constructor Invocation Pattern

JavaScript is a prototypal inheritance language. That means that objects can inherit properties directly from other objects. The language is class-free. This is a radical departure from the current fashion. Most languages today are classical. Prototypal inheritance is powerfully expressive, but is not widely understood.
JavaScript itself is not confident in its prototypal nature, so it offers an object-making syntax that is reminiscent of the classical languages. Few classical programmers found prototypal inheritance to be acceptable, and classically inspired syntax obscures the language’s true prototypal nature. It is the worst of both worlds.
If a function is invoked with the new prefix, then a new object will be created with a hidden link to the value of the function’s prototype member, and this will be bound to that new object.
The new prefix also changes the behavior of the return statement.
Functions that are intended to be used with the new prefix are called constructors. By convention, they are kept in variables with a capitalized name. If a constructor is called without the new prefix, very bad things can happen without a compile-time or runtime warning, so the capitalization convention is really important. Use of this style of constructor functions is not recommended. 

// Create a constructor function called Quo. It makes an object with a status property.
var Quo = function (string) {
	this.status = string;
};
// Give all instances of Quo (called a Class in classical programming like C++) a public method called get_status.
Quo.prototype.get_status = function ( ) {
	return this.status;
};
// Make an instance of Quo.
var myQuo = new Quo("confused");

Return Statement

When a function is invoked, it begins execution with the first statement, and ends when it hits the } that closes the function body. That causes the function to return control to the part of the program that invoked the function.
The return statement can be used to cause the function to return early. When return is executed, the function returns immediately without executing the remaining statements.
A function always returns a value. If the return value is not specified, then undefined is returned. If the function was invoked with the new prefix and the return value is not an object, then this (the new object) is returned instead.

Exception Handling

JavaScript provides an exception handling mechanism. Exceptions are unusual (but not completely unexpected) mishaps that interfere with the normal flow of a program. When such a mishap is detected, your program should throw an exception:
The throw statement interrupts execution of the function. It should be given an exception object containing a name property that identifies the type of the exception, and a descriptive message property. You can also add other properties.
The exception object will be delivered to the catch clause of a try statement:
If an exception is thrown within a try block, control will go to its catch clause.
A try statement has a single catch block that will catch all exceptions. If your handling depends on the type of the exception, then the exception handler will have to inspect the name to determine the type of the exception.





Recursion

A recursive function is a function that calls itself, either directly or indirectly. Recursion is a powerful programming technique in which a problem is divided into a set of similar subproblems, each solved with a trivial solution. Generally, a recursive function calls itself to solve its subproblems.
Example: Factorial Problem (n!)

Tags: Technology,JavaScript,