(public).sospep.events ~ view task ~ CREATE-article

<h1 style="text-align: center;">CREATE-article# #</h1>
<h2>[previously]</h2>
<ol>
<li>[reference]</li>
<ol>
<li>] <a href="http://www.codecademy.com/courses/javascript-lesson-205/1/5" target="_blank">http://www.codecademy.com/courses/javascript-lesson-205/1/5</a>&nbsp;&nbsp;</li>
<li>] <a href="https://medium.com/functional-javascript/recursion-282a6abbf3c5" target="_blank">https://medium.com/functional-javascript/recursion-282a6abbf3c5</a>&nbsp;</li>
</ol>
<li>[2015-06-27] NEW task IN tech-dev-sw/pln/language-javascript/<ol>
<li>] #&nbsp;5327 - CREATE-article# # - recursion</li>
</ol></li>
<li>&gt; [09:00] NEW task IN</li>
<ol>
<li>i] # 5327 CREATE-article#&nbsp;-recursion</li>
<li>i] codecademy tutorial 10/24, +] ref&nbsp;</li>
</ol></ol>
<h2>[currently]</h2>
<ol>
<li>] &nbsp;</li>
</ol>
<h2>[next]</h2>
<ol>
<li>]</li>
</ol>
&nbsp;
4] selections - recursion
&gt; write loop to do something
- example multiple num * by 10
&gt; put loop into function ( pass in arg)
&nbsp;
5] recursion&nbsp;
function factorial(n) { &nbsp; if (n === 0) { &nbsp;&nbsp;&nbsp; return 1; &nbsp; } &nbsp; &nbsp; // This is it! Recursion!! &nbsp; return n * factorial(n - 1); }
&nbsp;
There are a few key features of recursion that must be included in order for it to work properly.
The first is a base case: this is a statement, usually within a conditional clause like <code class="java">if</code>, that stops the recursion. If you don't have a base case, the recursion will go on infinitely and your program will crash. Crash = bad.
The second is a recursive case: this is the statement where the recursion actually happens: where the recursive function is called on itself.
function factorial(n) {&nbsp; &nbsp; // This is our Base Case - when n is equal to 0, we stop the recursion &nbsp; if (n === 0) { &nbsp;&nbsp;&nbsp; return 1; &nbsp; } &nbsp; &nbsp; // This is our Recursive Case &nbsp; // It will run for all other conditions except when n is equal to 0 &nbsp; return n * factorial(n - 1); }
&nbsp;
7] One other useful (and often necessary) feature of a recursive function is a termination condition.
This is a specific statement that will explicitly stop the recursion. The base case is a form of termination condition, though for our purposes here I will use termination condition to describe a statement that will cancel recursion in the event of bad input or other potential error.
To put this into practice, look at the factorial function. What would happen if we called it on a negative integer? Since the recursion will only stop when <code class="undefined">n</code> is equal to <code class="undefined">0</code>, and that would never happen with a negative integer, our program would crash.
In order to protect against this, we use a termination condition to ensure that the value passed to the function is valid, and will not crash our program. As a programmer, you must constantly be thinking about how to prepare for any type of situation and ensure that your code can handle it correctly.
function factorial(n) { &nbsp; if (n &lt; 0) { &nbsp;&nbsp;&nbsp; // Termination condition to prevent infinite recursion &nbsp;&nbsp;&nbsp; console.log("NO negative numbers"); &nbsp;&nbsp;&nbsp; return; &nbsp; } &nbsp; // Base case &nbsp; if (n === 0) { &nbsp;&nbsp;&nbsp; return 1; &nbsp; } &nbsp; // Recursive case &nbsp; return n * factorial(n -1); }
factorial(-1); factorial(5);
8] arguements in recursion
When building your recursive case (the code that will be repeated), one of the rules of thumb is to ensure that the arguments you use for the recursion will lead to your base case.
If the value we pass to the recursive function call is the same as the initial value, chances are our code will enter an infinite loop. And then, crash. Bad.
So, the question you have to ask yourself is "does the recursive case modify my arguments in such a way that each recursion brings it one step closer to the base case?"
&nbsp;
&nbsp;// What's wrong with this picture? Why won't this recursion work? &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return n * factorial(n);
// CORRECTED&nbsp;
return n * factorial(n-1);
&nbsp;9]&nbsp;try from scratch&nbsp;
Now that we've covered the bare essentials, try rebuilding the <code class="undefined">factorial()</code> function we've been working on, but this time write it all from scratch. To help you along, here are five questions that you can use whenever using recursion in your code:
<ul>
<li>What is/are the base case(s)?</li>
<li>What is/are the recursive case(s)?</li>
<li>Have I included any other necessary termination condition(s)?</li>
<li>Do the statements in the function lead to the base case?</li>
<li>Does the recursion build on the base case until the desired result is returned by the function?</li>
</ul>
// recursive function with arg function factorial(n) { &nbsp;&nbsp; console.log(n); // termination condition &nbsp;if ( n &lt; 1){ &nbsp;&nbsp;&nbsp; console.log("no negative numbers") &nbsp;} &nbsp;// base case &nbsp;if&nbsp; (n === 0) { &nbsp;&nbsp;&nbsp;&nbsp; return 1; &nbsp;&nbsp;&nbsp;&nbsp; } &nbsp;// return&nbsp; &nbsp;// ERROR&nbsp;return factorial(n-1);
return n * factorial(n-1);
 }
<div class="lesson-checkpoint__name">10] Iterative recursion</div>
<div class="article__content">
To start deconstructing recursion, let's first take a look at the difference between loops and recursive functions. In many situations, they are effectively interchangeable.
In fact, many programming languages don't have loops like <code class="java">for</code> or <code class="java">while</code>, but use recursion for everything.
In this example, each function does the same thing. One uses a loop, the other uses recursion.
</div>
&nbsp;
&nbsp;

~ view task ~ TaskGroup] language-javascript FROM [ Plan] planning-project IN [ calendars] technology-developer-www