What is a function? It is a section of program which performs a specific task. Most programs are split into into several 'functions', though the benefits of this approach become more apparent in larger programs. Associated with the concept of a function are the concepts of arguments/parameters, local variables, and global variables. So far our programs have consisted of one function, named main.

Here is an extended analogy:

Now consider one worker's task - perhaps it is to search a filing cabinet for a document. The search process will be the same, irrespective of the name of the document - but we need to pass the name of the document to the worker. In JT we can pass parameters (data values) into a function for it to make use of.

In other languages, functions are referred to as e.g. procedures, methods, subs, subroutines. Sometimes, parameters are termed arguments. These are all names for similar things.

Functions are used in all programming, and they are one of the hardest concepts you will meet. But there is no way to avoid them!

Built-in functions

Note the different way we use these:

print("hello");
n = getInt("how big?");

n= print("hello");  //no
getInt(How big?");  //no

print displays a message - it does not give us a value which we need to deal with. (it is termed a 'void' function.)

Example 1

function void main() { message(); message(); } function void message() { printLine("Welcome to programming."); printLine("I hope you enjoy the journey"); }

Note that the message is displayed twice. The key point is the order in which the statements are executed. We can make the program show us the order. We modify the program so that it becomes:

function void main() { alert("about to call message- first"); message(); alert("about to call message- second"); message(); } function void message() { alert("in message function"); printLine("Welcome to programming."); printLine("I hope you enjoy the journey"); alert("about to return"); }

The alerts would not normally be needed - they are there to help us understand. Run the program - you will see 6 alerts, showing you the order of execution - the 'flow' of the program.

We do not show these alerts here - you have to actually run the program!

Explanation

• The program has 2 functions - one is named main. Every JT program must have one function, named 'main'.
• We created our own function named message - the name is up to us.
• We call it up (get it to do its job) by putting

  message();

  note the ()
• It is rather like print. We don't call it by putting

  
  n = message();
  

• It doesn't pass a value back to us (it is not like getInt). We use void to specify this.
• A function must be declared before it can be called. The general form is:

  function void anyName()       // the 'header'
  {
  ....instructions - the 'body' of the function
  }
  
  

• When a function executes, it returns to where it was called from when it hits its terminating } . Insert any extra alerts if you want to confirm this.

Problems

Parameters

Run the following:

function void main() { message("Jim"); message("Sue"); } function void message(string person) { print("hi "); printLine(person); printLine("Welcome to programming."); printLine("I hope you enjoy the journey"); }

Note the results.

Explanation

• We now call it by adding a name, as in:

  
  message("Mike");
  

  We say that "Mike" is the actual parameter.
• The function has to be written to accept this 'parameter', as in:

  function void message(string person)

  We say that person is the formal parameter.

• When we call a function, the actual parameter gets copied into the formal parameter. Thus, "Mike" gets copied into person, which can then be used as a variable within the message function.
• If we call the function incorrectly, as in:

  
  message(3);   // error - int, not string - wrong type
  message();    //error - missing parameter
  n=message("jim");  //error - no result for us to use
  

  then a compilation error will result.
• The header says that the function needs one string. This can be provided in several ways:

  
  string name="";
  message("John");
  name=getString("Type your name:");
  message(name);
  
  

  i.e a string in quotes, or a variable.

A note on code formatting

Do this for every program from now on.

Example 2

function void main() { int x=0, y=0; x=getInt("Type first number"); y=getInt("Type second number"); add2(x,y); add2(88, 2); add(x+1, y+1); } function void add2(int a, int b) { int sum = 0; sum=a+b; print("the sum is "); printLine(sum); }

Note the indentation.

Firstly, the function declaration. We chose the name add2. There are 2 formal parameters, which we chose to name as a and b.

Note that the type of each formal parameter must be stated, and we use a comma to separate one from another.

In this particular example, the parameters are the same type, but this need not always be the case. The list of parameters can use int, double, or strings.

Now the calls. We have to supply two actual parameters, which must be int. We can use integer numbers, variables, or expressions, as the above example shows.

Problem

Local variables

function void main() { int a=3; alert(a); fred(); alert(a); } function void fred() { int a=6; alert(a); }

Run it. Note the display of the variable names and values, at the top right.

The display shows

main.a

fred.a

Why do you think that the display of names prefixes 'a' with a function name?

The answer: variables can only be used within the function in which they are declared. They are 'local' variables. (This is like saying that U.S. currency can only be used in the U.S.) Now, it might be that each function is written by different people (this is certainly the case for large programs). Coincidentally, they might choose the same name for variables (as i the above example). There is no problem. in the above; main has a variable called 'a', and so does fred.

There are two variables, which do not interfere with each other. When you ran the above, you saw that main's 'a' kept its value of 3, even after fred was called.

Local variables are created when a function is called. They are destoryed (lose their value) when we return from a function.

Incidentally, the same applies to formal parameters - they are treated like local variables.

So - to answer our question - the JT system prefixes each variable with its function, because variable names are not unique - we might have several variables of the same name.

Other languages have 'global' variables as well. They are declared above all the functions , and can be used by any of the functions. They are useful, but need careful use.

return

Here is an example, showing a function which takes in a number (of inches) and passes back(returns) its cm equivalent. Pretty-print it, then run it:

function void main() { double i = 0.0; i = insToCm(10.0); } function double insToCm(double inches) { double cm = 0.0; cm = inches*2.54; return cm; }

There are two new things - the absence of void in the header, and the return statement.

When a function needs to pass a value to the caller, we put the type of the value after the word 'function'.

We use 'return' to exit from the function, and to take back a value with it to the caller. Imagine that this value replaces the function name and parameters in the call. Thus the call is:

cm = insToCm(10.0);

cm= 25.4;

function double insToCm(double inches)
{
return inches * 2.54;
}

Problem

f = c*9/5 +32;

Example 4

function void main() { int x = 3, y = 4; printLine(big(x, y)); } function int big(int a, int b) { if(a>b) { return a; } else { return b; } }

Note that big returns a result, and we must use it in some way (e.g. print it, or store it somewhere. Here are some correct ways of calling big:

printLine(big(x, y));
x = big(8+x, 66);
x = big(3,4) + big(2,6);   // answer is 10

Now let us do something clever. We will code a function to find the biggest of 3 numbers. Firstly, look at this line:

x= big(big(3,4), 5);

The inner call of big runs first, bringing back 4. imagain that we now have:

x = big(4, 5);

Now we will write the big3 function - making use of our existing big function:

function int big3(int a, int b, innt c)
{
    return big(big(a, b), c);
}

x = big3(22, 5+3, 76);

This shows that functions can call functions that can call functions. . In this way, we can break up a large program into manageable parts.

problem.

Example 5

Of course, the user may type their name instead of a number. JT does not allow this type of checking, but 'real' languages do. In JT, getInt asks you to re-enter a number, but the prompt for this is standard, and cannot be customised.

Here we will code a function that returns with a positive integer (NB - in programming, 0 is usually defined as being positive). AS LONG AS the number entered is negative, we display an error message.

function void main() { int age = 0; age = getPosInt("How old?"); printLine(age); } function int getPosInt(string prompt) { int value = 0; value=getInt(prompt); while(value<0) { alert("Negative - please re-enter"); value = getInt(prompt); } return value; }

Run the program, and enter negative numbers.

Impossible problem

This cannot be done in JT, because return can pass back only one item. In other languages we might use 'pass-by-reference' or global variables (not available in JT) or the passing of an object (not in JT). If you can do all the problems in this chapter, you are definitely ready to move on to e.g Java, C++, C#.

Key Points

Try to sub-divide programs into functions.

Ensure that the number and type of actual parameters in the call match those of the formal parameters in the declaration.

Problems

1. Write a function called 'smaller', which accepts two integers, and which returns the value of the smaller one.

2. Write a function called 'printProd' which has two double inputs and no returned result. It prints the product of the two doubles.

4. Write a function called 'exactly' with two integer arguments, and an integer result. It should return 1 if the two numbers divide exactly, or 0 if they have a remainder. Use the % operator. For example:

 
     x = exactly(3,9);