(function(num) {
  if (num < 0) {
    return -num;
  } else {
    return num;
  };
});

(function(num) {
  if (num < 0) {
    return -num;
  } else {
    return num;
  };
})(-1);

// => 1

var abs = function(num) {
  if (num < 0) {
    return -num;
  } else {
    return num;
  };
};

abs(-1);
abs(0);
abs(1);
abs(-Infinity);

var r = 5;
function foo(n) {
    var r = 2;
    r *= n
    return r;
}

r // 5

foo(4) // 8

r // 5

¿IteraQué? Higher Order functions.

• Map

• Filter

• Reduce

function square(num) {
    return num * num
};

[ -1 , 1, 3, 8].map(square);

// [1, 1, 9, 64]

function isEven(num) { 
  if (num % 2 === 0) {
    return true;
  } else {
    return false;
  };
};

[0, 1, 2, 3, 4, 5].filter(isEven);

// [0, 2, 4]

function returnMax(prev, curr) {
  if (curr > prev) {
    return curr;
  } else {
    return prev;
  };
};

[-1, -5, 2, 10, 3, 5, 1, -99].reduce(returnMax);

 // 10

[-1, -5, 2, -10, 3, 5, 1, -99].reduce(returnMax);

 // 5

Function

+

Environment

===

Closures

function getMaxValueFactory () {
  var max = -Infinity;
  return function(prev, curr) {
    if (curr > max) {
      max = curr;
    }
      return max;
  }
};

var mf = getMaxValueFactory();

[-1, -5, 2, -10, 3, 5, 1, -99].reduce(mf);

 // 5

[-1, -5, 2, 10, 3, 5, 1, -99].reduce(mf);

 // 10

[-1, -5, 2, -10, 3, 5, 1, -99].reduce(mf);

 // 10

function fibNth(n) {
  if (n === 0) { 
    return 0;
  } else if (n === 1) {
    return 1;
  } else {
    return fibNth(n - 1) + fibNth(n - 2);
  }
};

function memoize(f) {
  var cache = {};
  return function (x) {
    if (!cache.hasOwnProperty(x)) {
      cache[x] = f(x);
    }
    return cache[x];
  }
};

var mf = memoize(fibNth)
mf(4) // => 3

var fact1 = function(n) {
  var result = 1;
  for(var i = n; i > 0; i--) {
    result *= i;
  };
  return result;
};

var fact2 = function(n) {
  if (n === 0) {
    return 1;
  } else {
    return n * fact2(n - 1);
  }
};

var fact3 = function(n) {
  var factFoo = function (accum, counter, maxCount) {
    if (counter > maxCount) {
      return accum;
    } else {
      return factFoo(accum * counter, counter + 1, maxCount);
    };
  };
  return factFoo(1, 1, n);
};

 (factorial 6)   -----.
 (fact-iter   1 1 6)  |
 (fact-iter   1 2 6)  |
 (fact-iter   2 3 6)  |
 (fact-iter   6 4 6)  |
 (fact-iter  24 5 6)  |
 (fact-iter 120 6 6)  |
 (fact-iter 720 7 6)  V
 720

 (factorial 6)        ------------------------.
 (* 6 (factorial 5))                          |
 (* 6 (* 5 (factorial 4)))                    |
 (* 6 (* 5 (* 4 (factorial 3))))              |
 (* 6 (* 5 (* 4 (* 3 (factorial 2)))))        |
 (* 6 (* 5 (* 4 (* 3 (* 2 (factorial 1))))))  |
 (* 6 (* 5 (* 4 (* 3 (* 2 1)))))              |
 (* 6 (* 5 (* 4 (* 3 2))))                    |
 (* 6 (* 5 (* 4 6)))                          |
 (* 6 (* 5 24))                               |
 (* 6 120)                                    |
 720          <-------------------------------'

function incrCounter(counter_id) {
  var el = document.getElementById(counter_id);
  var count = parseInt(el.textContent, 10);
  count++;
  el.textContent = count;
  return el;
};

function oneCount () {
  incrCounter('counter-1');
  setTimeout(oneCount, 500)
};

function twoCount () {
  incrCounter('counter-2');
  setTimeout(twoCount, 1000)
};

function start() {
  oneCount();
  twoCount();
};

var brutus = {name: "Brutus"}

brutus.identify = function(){
  return "I am " + this.name;
}

brutus.identify()

// 'I am Brutus'

brutus.identify.call({name:
                      "Spartacus"});

// 'I am Spartacus'

var Complex = function(real, img) {
  this.real = real;
  this.img = img;
  return this;
}

new Complex(2, 3)

// { real: 2, img: 3 }

Complex.prototype.addC = function(other) {
  return new Complex(this.real + other.real,
                     this.img + other.img);
};

var c = new Complex(2, 3)

c.addC(c)

// { real: 4, img: 6 }

Do you want to know more?

http://eloquentjavascript.com

Gracias

¿Preguntas?
next