+ Introduction
++ The process of a function calling itself is called recursion, and this function is called a recursive function. By using recursion, we can solve certain type of tasks easily. +
++ You may ask, if a function calls itself, it will lead to calling itself again, and again, and again... when would it stop? This is why it is always important to add a stop condition for recursive functions, + which is called the base case of the recursion. +
+Example
++ Let's investigate an interesting topic! How do bit by bots "reproduce"? Well, a newly created bit by bot need to learn how to create new bit by bots for a month; + after that, the bit by bot will create a new bit by bot every month. If we start with one single newly created bit by bot, as shown in the picture below, + it takes the bit by bot one month to learn how to create a new bit by bot and it will be creating one new bit by bot every month. + Remember, each newly created bit by bot only starts to create new bit by bots after it has spent one month learning the way to do so. +
++ In this picture, each row represents the total number of bit by bot of the corresponding month. For each month, each bit by bot that knows how to build bit by bots will + still be in the group in the next month (represented by the black branches) and will make a new bit by bot (represented by the red branches). +
+
+ Analysis of example
++ The number of bit by bots for each month actually follows a pattern. 1, 1, 2, 3, 5, 8, ... Starting from the third term, each term is the sum of the previous two terms. + This is a famous sequence called the Fibonacci sequence. Now, let's write a function that will give us the total number of bit by bots produced in such fashion + for any given month. +
++ The function should take a single input, namely the month, and output the total number of bit by bots for that month. (You can pause here briefly and try to write + a function that will work as described without using recursion. ) The code below is the recursive function that completes the task: +
+ + function fibonacci(month) {+ // Here the two ifs are the base case for the recursion, as
+ you can see they are not calling the function itself anymore
+ if (n == 0)
+ return 0;
+ if (n == 1 || n == 2)
+ return 1;
+ // This is where recursion occurs, the function is calling itself.
+ It says the output should be the sum of previous two months
+ else
+ return fibonacci(month - 1) + fibonacci(month - 2);
+ }
+
+ One important thing worth noting is how the function is evaluated. The only three cases where the function does not call itself repeatedly are month 0, 1, and 2. + These are our base cases and we set them to 0, 1, and 1 correspondingly. For any larger input, the function will need to call itself. +
++ For instance, if our input is 5, + fibonacci(5) will call fibonacci(4) and fibonacci(3); both of fibonacci(4) and fibonacci(3) are not fully evaluated yet, and they go on to call fibonacci(3) and + fibonacci(2), and fibonacci(2) and fibonacci(1). As stated before, fibonacci(2) and fibonacci(1) are just defined numbers, thus fibonacci(3) is determined, and is used to determine + the value of fibonacci(4); with both fibonacci(3) and fibonacci(4) completely evaluated, the value of fibonacci(5) is returned. +
+Quick exercise
+
+ See if you can figure out the console output of the following code, where input n is a positive number.
+
+ if (n == 1)
+ return 1;
+ else
+ return n + exercise(n - 1) + n;
+ }
+ console.log(exercise(5)); +
+