Function Concepts

Functions

A function is a unit of code that is often defined by its role within a greater code structure. Specifically, a function contains a unit of code that works on various inputs, many of which are variables, and produces concrete results involving changes to variable values or actual operations based on the inputs.

There are some examles of the aformentioned concept, these are:

Function Basics
Different Declarations
Different Declarations (2)
Callback Functions

Function Basics

Within a greater code structure, a function, which also may be called a subroutine, or a procedure, is "called" by the code, depending on a user event or as part of a greater operation. When called, the function operates on the inputs and produces the results.

A basic example is a function called "addtwo" that will take a veriable x, which is defined as an integer, and add two. The code within addtwo would look something like this:


							input "x"
x = x + 2
output "x"

An example of a function that operates on inputs instead may look like this:


							input "x"
if x > 5 then
print x
end

We have conceptualised our function - as seen above. Here, the function may or may not print, depending on the value of "x".

The function is an important concept in Programming as it enables you to build and structure applications perfectly. Also the logic behind it is very easy to understand, in every language... Garbage in, garbage out.

Different Function Declarations

In different languages functions are declared in different ways using different syntax.

These are the examples in the major programming languages:


							// JavaScript
function myFunction(x){
	
	var result = (x+2);
	return result;

}

// Java
public static int myFunction(int x){
	
	int result = (x+2);
	return result;

}

// Python
defs myFunction(x):
	
	result = x+2;
	return result;

}

// C#
static int myFunction(int x){
	
	return x+2;

}

// C++
int myFunction(int x){
	
	int result = (x+2);
	return result;

}

// PHP
function myFunction($x){
	
	$result = ($x+2);
	return $result;

}

Above are the different function declarations in different programming languages, as you can see, most of the syntax is the same, but the variable declarations are usually quite different at times.

Different Declarations (2)

Functions can also be declared in different ways. For example, in JavaScript, there are at least six ways of declaring a function.

Examples of how to declare functions in different ways in JS:


							// The arrow function 
// (its a shorthand anonymous function)

var absValue = (num) => {
	if(num < 0){
		return -num;
	}
	return num;
}

absValue(-10); // => 10
absValue(5); // => 5

// The generator function
// This function requires a * character

function* myGenerator(){
	
	var index = 0;
	while(true){

		yield index++;

	}

}
var g = myGenerator();

console.log(g.next().value); // => 0
console.log(g.next().value); // => 1

// function expression
// These are determined by a function keyword
// and then followed by an optional function
// name, a list of parameters in a pair of
// parenthesis and a pair of curly braces
// that delimits the body code

var solve = function(array){
  return array.length;
} // function expression

var methods = {
  nums: [5,3,9],
  mult: function(){
   return this.nums.reduce(function(acc,num){
	//func. exp
	return acc * num;
   });
  }
}
solve([1,4,2])); // => 8
methods.sum(); // => 135

There are many more ways to make functions and each way varies in strength to which situation you are in. For example, arrow functions are very useful if you dont need to have lots of code in your function and if it is just a simple equation, this also makes the code more abstract which is a principle of Object Oriented Programming. People who are not proficient with functions and programming will opt to use the "regular functions" (as mentioned in the different declarations section), however most advanced programmers do not use this way of building functions.

Functions are needed in different forms for different problems. Also sometimes different functions are used as a matter of personal choice.

Callback Function

A callback function is a function passed into another function as an argument, which is then invoked inside the outer function to complete some kind of routine or action.

An example of a callback function in JavaScript:


							function hiThere(name){
  alert('Hello there ' + name);
}

function processUserInput(callback){
	
  var name = prompt('Please enter 
  your name');
  callback(name);

}

processUserInput(hiThere);

This example is an "synchoronous callback" - it is executed immediately.

The "processUserInput" function is called at the bottom of the example, and in turn, it calls the "hiThere" function when it gets to the "callback()" line, then the hiThere function is executed.

There are many other concepts to functions, these are just the tip of the iceberg, handpicked by Jay.

These are (some) of the concepts of functions.

Sources: