# Generating Fibonacci sequence

``````var x=0,
var y=1;
var z;

fib = 0;
fib = 1;
for(i=2; i<=10; i++)
{
fib[i]=x+y;
x=y;
z=y;
}
``````

I'm trying to get to generate a simple Fibonacci sequence but there no output. Can anybody let me know what's wrong? You have never declared `fib` to be an array. Use `var fib = [];` to solve this.

Also, you're never modifying the `y` variable, neither using it.

The code below makes more sense, plus, it doesn't create unused variables:

``````var i;
var fib = []; // Initialize array!

fib = 0;
fib = 1;
for (i = 2; i <= 10; i++) {
// Next fibonacci number = previous + one before previous
// Translated to JavaScript:
fib[i] = fib[i - 2] + fib[i - 1];
console.log(fib[i]);
}`````` You should've declared the `fib` variable to be an array in the first place (such as `var fib = []` or `var fib = new Array()`) and I think you're a bit confused about the algorithm.
If you use an array to store the fibonacci sequence, you do not need the other auxiliar variables (`x,y,z`) :

``````var fib = [0, 1];
for(var i=fib.length; i<10; i++) {
fib[i] = fib[i-2] + fib[i-1];
}
console.log(fib);
``````

### Click for the demo

You should consider the recursive method too (note that this is an optimised version) :

``````function fib(n, undefined){
if(fib.cache[n] === undefined){
fib.cache[n] = fib(n-1) + fib(n-2);
}

return fib.cache[n];
}
fib.cache = [0, 1, 1];
``````

and then, after you call the fibonacci function, you have all the sequence in the `fib.cache` field :

``````fib(1000);
console.log(fib.cache);
`````` Yet another answer would be to use es6 generator functions.

``````function* fib() {
var current = a = b = 1;

yield 1;

while (true) {
current = b;

yield current;

b = a + b;
a = current;
}
}

sequence = fib();
sequence.next(); // 1
sequence.next(); // 1
sequence.next(); // 2
// ...
`````` You're not assigning a value to `z`, so what do you expect `y=z;` to do? Likewise you're never actually reading from the array. It looks like you're trying a combination of two different approaches here... try getting rid of the array entirely, and just use:

``````// Initialization of x and y as before

for (i = 2; i <= 10; i++)
{
z = x + y;
x = y;
y = z;
}
``````

EDIT: The OP changed the code after I'd added this answer. Originally the last line of the loop was `y = z;` - and that makes sense if you've initialized `z` as per my code.

If the array is required later, then obviously that needs to be populated still - but otherwise, the code I've given should be fine. The golden ration "phi" ^ n / sqrt(5) is asymptotic to the fibonacci of n, if we round that value up, we indeed get the fibonacci value.

``````function fib(n) {
let phi = (1 + Math.sqrt(5))/2;
let asymp = Math.pow(phi, n) / Math.sqrt(5);

return Math.round(asymp);
}

fib(1000); // 4.346655768693734e+208 in just 0.62s
``````

This runs faster on large numbers compared to the recursion based solutions. There is also a generalization of Binet's formula for negative integers:

``````static float phi = (1.0f + sqrt(5.0f)) / 2.0f;

int generalized_binet_fib(int n) {
return round( (pow(phi, n) - cos(n * M_PI) * pow(phi, -n)) / sqrt(5.0f) );
}

...

for(int i = -10; i < 10; ++i)
printf("%i ", generalized_binet_fib(i));
`````` # A quick way to get ~75

ty @geeves for the catch, I replaced `Math.floor` for `Math.round` which seems to get it up to 76 where floating point issues come into play :/ ... either way, I wouldn't want to be using recursion up and until that point.

``````/**
* Binet Fibonacci number formula for determining
* sequence values
* @param {int} pos - the position in sequence to lookup
* @returns {int} the Fibonacci value of sequence @pos
*/

var test = [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,165580141,267914296,433494437,701408733,1134903170,1836311903,2971215073,4807526976,7778742049,12586269025,20365011074,32951280099,53316291173,86267571272,139583862445,225851433717,365435296162,591286729879,956722026041,1548008755920,2504730781961,4052739537881,6557470319842,10610209857723,17167680177565,27777890035288,44945570212853,72723460248141,117669030460994,190392490709135,308061521170129,498454011879264,806515533049393,1304969544928657,2111485077978050,3416454622906707,5527939700884757,8944394323791464,14472334024676221,23416728348467685,37889062373143906,61305790721611591,99194853094755497,160500643816367088,259695496911122585,420196140727489673,679891637638612258,1100087778366101931,1779979416004714189,2880067194370816120,4660046610375530309,7540113804746346429,12200160415121876738,19740274219868223167,31940434634990099905,51680708854858323072,83621143489848422977,135301852344706746049,218922995834555169026];
var fib = function (pos) {
return Math.round((Math.pow( 1 + Math.sqrt(5), pos)
- Math.pow( 1 - Math.sqrt(5), pos))
/ (Math.pow(2, pos) * Math.sqrt(5)));
};

/* This is only for the test */
var max = test.length,
i = 0,
frag = document.createDocumentFragment(),
_div = document.createElement('div'),
_text = document.createTextNode(''),
div,
text,
err,
num;
for ( ; i < max; i++) {
div = _div.cloneNode();
text = _text.cloneNode();
num = fib(i);
if (num !== test[i]) {
err = i + ' == ' + test[i] + '; got ' + num;
div.style.color = 'red';
}
text.nodeValue = i + ': ' + num;
div.appendChild(text);
frag.appendChild(div);
}
document.body.appendChild(frag);`````` If using es6

``````function fib(n, prev = 0, current = 1) {
return !n ? prev + current : fib(--n, current, prev+current)
}

var f = fib(10)
`````` I just would like to contribute with a tail call optimized version by ES6. It's quite simple;

``````var fibonacci = (n, f = 0, s = 1) => n === 0 ? f : fibonacci(--n, s, f + s);
console.log(fibonacci(12));`````` I know this is a bit of an old question, but I realized that many of the answers here are utilizing for loops rather than while loops.

Sometimes, while loops are faster than for loops, so I figured I'd contribute some code that runs the Fibonacci sequence in a while loop as well! Use whatever you find suitable to your needs.

``````function fib(length) {
var fibArr = [],
i = 0,
j = 1;
fibArr.push(i);
fibArr.push(j);
while (fibArr.length <= length) {
fibArr.push(fibArr[j] + fibArr[i]);
j++;
i++;
}
return fibArr;
};
fib(15);
`````` sparkida, found an issue with your method. If you check position 10, it returns 54 and causes all subsequent values to be incorrect. You can see this appearing here: http://jsfiddle.net/createanaccount/cdrgyzdz/5/

``````(function() {

function fib(n) {
var root5 = Math.sqrt(5);
var val1 = (1 + root5) / 2;
var val2 = 1 - val1;
var value = (Math.pow(val1, n) - Math.pow(val2, n)) / root5;

return Math.floor(value + 0.5);
}
for (var i = 0; i < 100; i++) {
document.getElementById("sequence").innerHTML += (0 < i ? ", " : "") + fib(i);
}

}());``````
``````<div id="sequence">

</div>`````` You can get some cache to speedup the algorithm...

``````var tools = {

fibonacci : function(n) {
var cache = {};

// optional seed cache
cache = 1;
cache = 2;
cache = 3;
cache = 5;
cache = 8;

return execute(n);

function execute(n) {
// special cases 0 or 1
if (n < 2) return n;

var a = n - 1;
var b = n - 2;

if(!cache[a]) cache[a] = execute(a);
if(!cache[b]) cache[b] = execute(b);

return cache[a] + cache[b];
}
}
};
`````` Here are examples how to write fibonacci using recursion, generator and reduce.

``````'use strict'

//------------- using recursion ------------
function fibonacciRecursion(n) {
return (n < 2) ? n : fibonacciRecursion(n - 2) + fibonacciRecursion(n - 1)
}

// usage
for (let i = 0; i < 10; i++) {
console.log(fibonacciRecursion(i))
}

//-------------- using generator -----------------
function* fibonacciGenerator() {
let a = 1,
b = 0
while (true) {
yield b;
[a, b] = [b, a + b]
}
}

// usage
const gen = fibonacciGenerator()
for (let i = 0; i < 10; i++) {
console.log(gen.next().value)
}

//------------- using reduce ---------------------
function fibonacciReduce(n) {
return new Array(n).fill(0)
.reduce((prev, curr) => ([prev, prev] = [prev, prev + prev], prev), [0, 1])
}

// usage
for (let i = 0; i < 10; i++) {
console.log(fibonacciReduce(i))
}`````` Another easy way to achieve this:

``````// declare the array starting with the first 2 values of the fibonacci sequence
var fibonacci = [0,1];

function listFibonacci() {
// starting at array index 1, and push current index + previous index to the array
for (var i = 1; i < 10; i++) {
fibonacci.push(fibonacci[i] + fibonacci[i - 1]);
}
console.log(fibonacci);
}

listFibonacci();
`````` You Could Try This Fibonacci Solution Here

``````var a = 0;
console.log(a);
var b = 1;
console.log(b);
var c;
for (i = 0; i < 3; i++) {
c = a + b;
console.log(c);
a = b + c;
console.log(a);
b = c + a;
console.log(b);
}
`````` fibonacci 1,000 ... 10,000 ... 100,000

Some answers run into issues when trying to calculate large fibonacci numbers. Others are approximating numbers using phi. This answer will show you how to calculate a precise series of large fibonacci numbers without running into limitations set by JavaScript's floating point implementation.

Below, we generate the first 1,000 fibonacci numbers in a few milliseconds. Later, we'll do 100,000!

``````const { fromInt, toString, add } =
Bignum

const bigfib = function* (n = 0)
{
let a = fromInt (0)
let b = fromInt (1)
let _
while (n >= 0) {
yield toString (a)
_ = a
a = b
n = n - 1
}
}

console.time ('bigfib')
const seq = Array.from (bigfib (1000))
console.timeEnd ('bigfib')
// 25 ms

console.log (seq.length)
// 1001

console.log (seq)
// [ 0, 1, 1, 2, 3, ... 995 more elements ]
``````

Let's see the 1,000th fibonacci number

``````console.log (seq )
// 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875
``````

10,000

This solution scales quite nicely. We can calculate the first 10,000 fibonacci numbers in under 2 seconds. At this point in the sequence, the numbers are over 2,000 digits long – way beyond the capacity of JavaScript's floating point numbers. Still, our result includes precise values without making approximations.

``````console.time ('bigfib')
const seq = Array.from (bigfib (10000))
console.timeEnd ('bigfib')
// 1877 ms

console.log (seq.length)
// 10001

console.log (seq  .length)
// 2090

console.log (seq )
// 3364476487 ... 2070 more digits ... 9947366875
``````

Of course all of that magic takes place in `Bignum`, which we will share now. To get an intuition for how we will design `Bignum`, recall how you added big numbers using pen and paper as a child...

``````  1259601512351095520986368
+   50695640938240596831104
---------------------------
?
``````

You add each column, right to left, and when a column overflows into the double digits, remembering to carry the 1 over to the next column...

``````                 ... <-001
1259601512351095520986368
+   50695640938240596831104
---------------------------
... <-472``````

Above, we can see that if we had two 10-digit numbers, it would take approximately 30 simple additions (3 per column) to compute the answer. This is how we will design `Bignum` to work

``````const Bignum =
{ fromInt: (n = 0) =>
n < 10
? [ n ]
: [ n % 10, ...Bignum.fromInt (n / 10 >> 0) ]

, fromString: (s = "0") =>
Array.from (s, Number) .reverse ()

, toString: (b) =>
Array.from (b) .reverse () .join ('')

{
const len = Math.max (b1.length, b2.length)
let carry = 0
for (let i = 0; i < len; i = i + 1) {
const x = b1[i] || 0
const y = b2[i] || 0
const sum = x + y + carry
carry = sum / 10 >> 0
}
if (carry > 0) answer.push (carry)
}
}
``````

We'll run a quick test to verify our example above

``````const x =
fromString ('1259601512351095520986368')

const y =
fromString ('50695640938240596831104')

// 1310297153289336117817472
``````

And now a complete program demonstration. Expand it to calculate the precise 10,000th fibonacci number in your own browser! Note, the result is the same as the answer provided by wolfram alpha

``````const Bignum =
{ fromInt: (n = 0) =>
n < 10
? [ n ]
: [ n % 10, ...Bignum.fromInt (n / 10 >> 0) ]

, fromString: (s = "0") =>
Array.from (s, Number) .reverse ()

, toString: (b) =>
Array.from (b) .reverse () .join ('')

{
const len = Math.max (b1.length, b2.length)
let carry = 0
for (let i = 0; i < len; i = i + 1) {
const x = b1[i] || 0
const y = b2[i] || 0
const sum = x + y + carry
carry = sum / 10 >> 0
}
if (carry > 0) answer.push (carry)
}
}

const { fromInt, toString, add } =
Bignum

const bigfib = function* (n = 0)
{
let a = fromInt (0)
let b = fromInt (1)
let _
while (n >= 0) {
yield toString (a)
_ = a
a = b
n = n - 1
}
}

console.time ('bigfib')
const seq = Array.from (bigfib (10000))
console.timeEnd ('bigfib')
// 1877 ms

console.log (seq.length)
// 10001

console.log (seq  .length)
// 2090

console.log (seq )
// 3364476487 ... 2070 more digits ... 9947366875``````

100,000

I was just curious how far this little script could go. It seems like the only limitation is just time and memory. Below, we calculate the first 100,000 fibonacci numbers without approximation. Numbers at this point in the sequence are over 20,000 digits long, wow! It takes 3.18 minutes to complete but the result still matches the answer from wolfram alpha

``````console.time ('bigfib')
const seq = Array.from (bigfib (100000))
console.timeEnd ('bigfib')
// 191078 ms

console.log (seq .length)
// 100001

console.log (seq  .length)
// 20899

console.log (seq )
// 2597406934 ... 20879 more digits ... 3428746875
`````` I like the fact that there are so many ways to create a fibonacci sequence in JS. I will try to reproduce a few of them. The goal is to output a sequence to console (like `{n: 6, fiboNum: 8}`)

## Good 'ol closure

``````// The IIFE form is purposefully omitted. See below.

const fiboGenClosure = () => {
let [a, b] = [0, 1];
let n = 0;
return (fiboNum = a) => {
[a, b] = [b, a + b];
return {
n: n++,
fiboNum: fiboNum
};
};
}

// Gets the sequence until given nth number. Always returns a new copy of the main function, so it is possible to generate multiple independent sequences.

const generateFiboClosure = n => {
const newSequence = fiboGenClosure();
for (let i = 0; i <= n; i++) {
console.log(newSequence());
}
}

generateFiboClosure(21);``````

## Fancy ES6 generator

Similar to the closure pattern above, using the advantages of generator function and for..of loop.

``````// The 'n' argument is a substitute for index.

function* fiboGen(n = 0) {
let [a, b] = [0, 1];
while (true) {
yield [a, n++];
[a, b] = [b, a + b];
}
}

// Also gives a new sequence every time is invoked.

const generateFibonacci = n => {
const iterator = fiboGen();
for (let [value, index] of iterator) {
console.log({
n: index,
fiboNum: value
});
if (index >= n) break;
}
}

generateFibonacci(21);``````

## Tail call recursion

This one is a little tricky, because, now in late 2018, TC optimization is still an issue. But honestly – if you don't use any smart tricks to allow the default JS engine to use a really big numbers, it will get dizzy and claims that the next fibonacci number is "Infinity" by iteration 1477. The stack would probably overflow somewhere around iteration 10 000 (vastly depends on browser, memory etc…). Could be probably padded by try… catch block or check if "Infinity" was reached.

``````const fibonacciRTC = (n, i = 0, a = 0, b = 1) => {
console.log({
n: i,
fibonacci: a
});
if (n === 0) return;
return fibonacciRTC(--n, ++i, b, a + b);
}

fibonacciRTC(21)``````

It can be written as a one-liner, if we throe away the `console.log` thing and simply return a number:

``````const fibonacciRTC2 = (n, a = 0, b = 1) => n === 0 ? a : fibonacciRTC2(n - 1, b, a + b);

console.log(fibonacciRTC2(21))``````

## Important note!

As I found out reading this mathIsFun article, the fibonacci sequence is valid for negative numbers as well! I tried to implement that in the recursive tail call form above like that:

``````const fibonacciRTC3 = (n, a = 0, b = 1, sign = n >= 0 ? 1 : -1) => {
if (n === 0) return a * sign;
return fibonacciRTC3(n - sign, b, a + b, sign);
}

console.log(fibonacciRTC3(8)); // 21
console.log(fibonacciRTC3(-8)); // -21`````` This script will take a number as parameter, that you want your Fibonacci sequence to go.

``````function calculateFib(num) {
var fibArray = [];
var counter = 0;

if (fibArray.length == 0) {
fibArray.push(
counter
);
counter++
};

fibArray.push(fibArray[fibArray.length - 1] + counter);

do {
var lastIndex = fibArray[fibArray.length - 1];
var snLastIndex = fibArray[fibArray.length - 2];
if (lastIndex + snLastIndex < num) {
fibArray.push(lastIndex + snLastIndex);
}

} while (lastIndex + snLastIndex < num);

return fibArray;

};
`````` This is what I came up with

``````//fibonacci numbers
//0,1,1,2,3,5,8,13,21,34,55,89
//print out the first ten fibonacci numbers
'use strict';
function printFobonacciNumbers(n) {
var firstNumber = 0,
secondNumber = 1,
fibNumbers = [];
if (n <= 0) {
return fibNumbers;
}
if (n === 1) {
return fibNumbers.push(firstNumber);
}
//if we are here,we should have at least two numbers in the array
fibNumbers = firstNumber;
fibNumbers = secondNumber;
for (var i = 2; i <= n; i++) {
fibNumbers[i] = fibNumbers[(i - 1)] + fibNumbers[(i - 2)];
}
return fibNumbers;
}

var result = printFobonacciNumbers(10);
if (result) {
for (var i = 0; i < result.length; i++) {
console.log(result[i]);
}
}
`````` Beginner, not too elegant, but shows the basic steps and deductions in JavaScript

``````/* Array Four Million Numbers */
var j = [];
var x = [1,2];
var even = [];
for (var i = 1;i<4000001;i++){
j.push(i);
}
// Array Even Million
i = 1;
while (i<4000001){
var k = j[i] + j[i-1];
j[i + 1]  = k;
if (k < 4000001){
x.push(k);
}
i++;
}
var total = 0;
for (w in x){
if (x[w] %2 === 0){
even.push(x[w]);
}
}
for (num in even){
total += even[num];
}
console.log(x);
console.log(even);
console.log(total);
`````` My 2 cents:

``````function fibonacci(num) {
return Array.apply(null, Array(num)).reduce(function(acc, curr, idx) {
return idx > 2 ? acc.concat(acc[idx-1] + acc[idx-2]) : acc;
}, [0, 1, 1]);
}

console.log(fibonacci(10));`````` I would like to add some more code as an answer :), Its never too late to code :P

``````function fibonacciRecursive(a, b, counter, len) {
if (counter <= len) {
console.log(a);
fibonacciRecursive(b, a + b, counter + 1, len);
}
}

fibonacciRecursive(0, 1, 1, 20);
``````

Result

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Fibonacci (one-liner)

``````function fibonacci(n) {
return (n <= 1) ? n : fibonacci(n - 1) + fibonacci(n - 2);
}
``````

Fibonacci (recursive)

``````function fibonacci(number) {
// n <= 1
if (number <= 0) {
return n;
} else {
// f(n) = f(n-1) + f(n-2)
return fibonacci(number - 1) + fibonacci(number - 2);
}
};

console.log('f(14) = ' + fibonacci(14)); // 377``````

Fibonacci (iterative)

`````` function fibonacci(number) {
// n < 2
if (number <= 0) {
return number ;
} else {
var n = 2; // n = 2
var fn_1 = 0; // f(n-2), if n=2
var fn_2 = 1; // f(n-1), if n=2

// n >= 2
while (n <= number) {
var aa = fn_2; // f(n-1)
var fn = fn_1 + fn_2; // f(n)

// Preparation for next loop
fn_1 = aa;
fn_2 = fn;

n++;
}

return fn_2;
}
};

console.log('f(14) = ' + fibonacci(14)); // 377``````

Fibonacci (with Tail Call Optimization)

``````function fibonacci(number) {
if (number <= 1) {
return number;
}

function recursion(length, originalLength, previous, next) {
if (length === originalLength)
return previous + next;

return recursion(length + 1, originalLength, next, previous + next);
}

return recursion(1, number - 1, 0, 1);
}

console.log(`f(14) = \${fibonacci(14)}`); // 377`````` Here is a function that displays a generated Fibonacci sequence in full while using recursion:

``````function fibonacci (n, length) {
if (n < 2) {
return ;
}
if (n < 3) {
return [1, 1];
}

let a = fibonacci(n - 1);
a.push(a[n - 2] + a[n - 3]);
return (a.length === length)
? a.map(val => console.log(val))
: a;

};
``````

The output for `fibonacci(5, 5)` will be:

``````1
1
2
3
5
``````

The value that is assigned to `a` is the returned value of the `fibonacci` function. On the following line, the next value of the fibonacci sequence is calculated and pushed to the end of the `a` array.

The `length` parameter of the `fibonacci` function is used to compare the length of the sequence that is the `a` array and must be the same as `n` parameter. When the length of the sequence matches the length parameter, the `a` array is outputted to the console, otherwise the function returns the `a` array and repeats. According to the Interview Cake question, the sequence goes 0,1,1,2,3,5,8,13,21. If this is the case, this solution works and is recursive without the use of arrays.

``````function fibonacci(n) {
return n < 1 ? 0
: n <= 2 ? 1
: fibonacci(n - 1) + fibonacci(n - 2);
}

console.log(fibonacci(4));
``````

Think of it like this.

``````   fibonacci(4)   .--------> 2 + 1 = 3
|          /               |
'--> fibonacci(3) + fibonacci(2)
|    ^
|    '----------- 2 = 1 + 1 <----------.
1st step -> |                     ^                |
|                     |                |
'---->  fibonacci(2) -' + fibonacci(1)-'
``````

Take note, this solution is not very efficient though. Here's a simple function to iterate the Fibonacci sequence into an array using arguments in the `for` function more than the body of the loop:

``````fib = function(numMax){
for(var fibArray = [0,1], i=0,j=1,k=0; k<numMax;i=j,j=x,k++ ){
x=i+j;
fibArray.push(x);
}
console.log(fibArray);
}

fib(10)
``````

[ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 ] ``````function fib(n) {
if (n <= 1) {
return n;
} else {
return fib(n - 1) + fib(n - 2);
}
}

fib(10); // returns 55
`````` ``````<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<title>fibonacci series</title>
<script type="text/javascript">
function generateseries(){
var fno = document.getElementById("firstno").value;
var sno = document.getElementById("secondno").value;
var a = parseInt(fno);
var result = new Array();
result = a;
var b = ++fno;
var c = b;
while (b <= sno) {
result.push(c);
document.getElementById("maindiv").innerHTML = "Fibonacci Series between "+fno+ " and " +sno+ " is " +result;
c = a + b;
a = b;
b = c;
}
}
function numeric(evt){
var theEvent = evt || window.event;
var key = theEvent.keyCode || theEvent.which;
key = String.fromCharCode(key);
var regex = /[0-9]|\./;
if (!regex.test(key)) {
theEvent.returnValue = false;
if (theEvent.preventDefault)
theEvent.preventDefault();
}
}

</script>
<h1 align="center">Fibonacci Series</h1>
<body>
<div id="resultdiv" align="center">
<input type="text" name="firstno" id="firstno" onkeypress="numeric(event)"><br>
<input type="text" name="secondno" id="secondno" onkeypress="numeric(event)"><br>
<input type="button" id="result" value="Result" onclick="generateseries();">
<div id="maindiv"></div>
</div>
</body>
</html>
`````` ``````function fibo(count) {

//when count is 0, just return
if (!count) return;

//Push 0 as the first element into an array
var fibArr = ;

//when count is 1, just print and return
if (count === 1) {
console.log(fibArr);
return;
}

//Now push 1 as the next element to the same array
fibArr.push(1);

//Start the iteration from 2 to the count
for(var i = 2, len = count; i < len; i++) {
//Addition of previous and one before previous
fibArr.push(fibArr[i-1] + fibArr[i-2]);
}

//outputs the final fibonacci series
console.log(fibArr);
}
``````

Whatever count we need, we can give it to above fibo method and get the fibonacci series upto the count.

``````fibo(20); //output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]
`````` There is no need for slow loops, generators or recursive functions (with or without caching). Here is a fast one-liner using `Array` and `reduce`.

ECMAScript 6:

``````var fibonacci=(n)=>Array(n).fill().reduce((a,b,c)=>a.concat(c<2?c:a[c-1]+a[c-2]),[])
``````

ECMAScript 5:

``````function fibonacci(n){
return Array.apply(null,{length:n}).reduce(function(a,b,c){return a.concat((c<2)?c:a[c-1]+a[c-2]);},[]);
}
``````

Tested in Chrome 59 (Windows 10):

``````fibonacci(10); // 0 ms -> (10) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
``````

JavaScript can handle numbers up to 1476 before reaching `Infinity`.

``````fibonacci(1476); // 11ms -> (1476) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...]
`````` Another implementation, while recursive is very fast and uses single inline function. It hits the javascript 64-bit number precision limit, starting 80th sequence (as do all other algorithms): For example if you want the 78th term (78 goes in the last parenthesis):

``````(function (n,i,p,r){p=(p||0)+r||1;i=i?i+1:1;return i<=n?arguments.callee(n,i,r,p):r}(78));
``````

will return: 8944394323791464

This is backwards compatible all the way to ECMASCRIPT4 - I tested it with IE7 and it works!