Introducción al curso

1

¡Alto! Tenemos una nueva versión de este curso para ti

2

Bienvenidos al Curso de Fundamentos de JavaScript

3

Repositorio de este curso de fundamentos de JS

Primeros pasos en JavaScript

4

Variables

5

Variables: Strings

6

Variables: Números

7

Funciones

8

El alcance de las funciones

9

Objetos

10

Desestructurar objetos

11

Parámetros como referencia o como valor

12

Comparaciones en JavaScript

Estructuras de Control y Funciones

13

Condicionales

14

Funciones que retornan valores

15

Arrow functions

16

Estructuras repetitivas: for

17

Estructuras repetitivas: while

18

Estructuras repetitivas: do-while

19

Condicional múltiple: switch

Arrays

20

Introducción a arrays

21

Filtrar un array

22

Transformar un array

23

Reducir un array a un valor

Programación Orientada a Objetos en JavaScript

24

Cómo funcionan las clases en JavaScript

25

Modificando un prototipo

26

El contexto de las funciones: quién es this

27

La verdad oculta sobre las clases en JavaScript

28

Clases en JavaScript

Asincronismo

29

Funciones como parámetros

30

Cómo funciona el asincronismo en JavaScript

31

Cómo funciona el tiempo en JavaScript

32

¿Qué pasó con swapi.co?

33

Callbacks

34

Haciendo múltiples requests

35

Manejando el Orden y el Asincronismo en JavaScript

36

Manejo de errores con callbacks

37

Promesas

38

Promesas Encadenadas

39

Múltiples promesas en paralelo

40

Async-await: lo último en asincronismo

Juego de HTML

41

Comenzando el juego

42

Generando una secuencia de números

43

Iluminando la secuencia de colores

44

Obteniendo el input del usuario

45

Agregando la verificación del color elegido

46

Agregando los estados finales del juego

47

Conclusiones del curso

Complementos

48

Diferencias entre var, let y const

49

Memoización: ahorrando cómputo

50

¿Hace cuántos días naciste?

51

Funciones recursivas

52

Entiende los closures de JavaScript

53

Estructuras de datos inmutables

54

Cambiando de contexto al llamar a una función

55

¿Cuándo hace falta poner el punto y coma al final de la línea?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Memoización: ahorrando cómputo

49/55
Recursos

La memorización es una técnica de programación que nos permite ahorrar cómputo o procesamiento en JavaScript, al ir almacenando el resultado invariable de una función para que no sea necesario volver a ejecutar todas las instrucciones de nuevo, cuando se vuelva a llamar con los mismos parámetros. Es similar a usar memoria cache.

Aportes 144

Preguntas 16

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

No es necesario llamarle this.cache. Puede ser this.pepito e igual funciona porque lo que está haciendo sacha es crearle al objeto window un nuevo atributo llamado cache. Se puede ver en window.cache y se puede acceder a ella desde cualquier funcion, no solo factorial.

Siento que falta el uso de casos prácticos para estos conceptos.

Resumen de la Clase

Memoización: ahorrando cómputo

Este proceso nos va a permitir ahorrar procesamiento, ahorrar cómputo, guardando ciertos resultados de algunas cuentas.

Usaremos otro ejemplo de recursividad:

Factoriales:

!6 = 6* 5 * 4 * 3 * 2 * 1 = 720

!12 = 12 * 11 * 10 * 9 * … * 1 == 12 * 11 * 10 * 9 * 8 * 7 * !6

Cómo guardamos los resultados para no tener que volver a realizar cuentas ya hechas.


	function factorial(n) {
		if(n === 1) {
			return 1
		}
		returnn * factorial(n - 1)
	}

Ahora guardamos en una cache los resultados de las operaciones ya hechas.


	function factorial(n) {
		if(!this.cache) {
			this.cache = {}
		}
		if (this.cache[n]){
			return this.cache[n]
		}
		if(n === 1) {
			return 1
		}
		this.cache[n] = n * factorial(n - 1)
		return this.cache[n]
	}

Posiblemente Sacha nunca vea este comentario, pero para todos los demás les dejo algunos posibles errores en el código que no mencionó.

Sacha marca que el mínimo número para sacar su factorial es 1, cosa que no es cierto, el número 0 es el número mínimo, lo cual equivale a 1.

Por otro lado, no están permitidos los números negativos. Aquí dejo mi código que soluciona estas fallas.

function factorial(n) {

  if (n >= 0) {

    if (n === 0) {
      n = 1
    } else {
      n = n * factorial(n - 1)
    }

    return n

  } else {
    console.log('Negative numbers are not allowed')
  }

}

Nunca había escuchado de la memoizacion, excelente para ahorrar procesamiento.

A la función de factorial le agregué para que tenga en cuenta el factorial de 0 y no pueda ingresar numeros negativos.

function factorial(n){
   if (n < 0){
        return 'Entrada no válida, solo numeros positivos'
    }

    if (!this.cache){
        this.cache = {}                
    }
    
    if (this.cache[n]){
        return this.cache[n]
    }
    if (n === 1 || n === 0){
        this.cache[n] = 1
        return this.cache[n]
    }

    this.cache[n] = n * factorial(n - 1)
    return this.cache[n] 
} ```

¿Quien mas pensó que era un error de tipeo? jajajaja

Como ejercicio se mira mu bien, pero me queda rondando en la cabeza computo vs memoria, cual es el menor de dos males, ya en un caso practico

Con la Memoización es posible ahorrar operaciones costosas guardando en cache resultados y con ello ahorrar en procesamiento.

A esta metodologia, se la llama programacion dinamica 😃

Esto es muy interesante

Muy complejo este tema, pero realmente muy util, espero poder poder encontrar mas informacion acerca de esto

function factorial(n){
    if(!this.cache){
        this.cache ={};
    }else if (this.cache[n]){
        return this.cache[n];
    }
    if (n>1){
        this.cache[n] = n * factorial(n-1);
        return this.cache[n];
    }else if(n===1){
        return 1;
    }
    
   
}
console.log(factorial(7));

La memoización es una técnica de programación que nos permite ahorrar cómputo o procesamiento en JavaScript, al ir almacenando el resultado invariable de una función para que no sea necesario volver a ejecutar todas las instrucciones de nuevo, cuando se vuelva a llamar con los mismos parámetros. Es similar a usar memoria cache.

programación dinámica

Memorización: Nos permite ahorrar procesamiento en JavaScript
¿Cómo lo hace?
Almacena el resultado invariable de una función (para que no sea necesario volver a ejecutar el mismo código), cuando volvamos a llamar la misma función con los mismos parámetros.

La memoizacion es increíble y este curso es simplemente necesario. Ánimo a los que no entiendan, denle su tiempo y practiquen.

Si bien es simple, es importante aclarar el funcionamiento de return. return lo que hace es devolver un valor y terminar con la ejecución de la función actual. Es decir, si queda código debajo de return, este no será ejecutado. Lo aclaro porque hasta ahora solo veíamos el return al final de la función, pero podemos ponerlo en cualquier lado o ponerlo varias veces.

Uhhhh esto si que no lo sabía, wow, esto está genial, usar el caché, empezaré a usarlo jaja

a mi me quedo una duda al realizar por primera vez el factorial de el 6 por ejemplo, ya queda guarda en la cache al hacerla otra vez solo a el dato que esta en cache, pero, ¿también se guarda en cache el factorial de 5, 4, 3 y 2?

Con esta la memorizacion ahorramos computo al guardar valores claves. En el ejercicio de la clase, clcular el factorial de n, guardamos los valors de n si ya fueron calculados antes. Por ejemplo, calculamos factorial de 9 en un principio se hara el calculo realizando las operaciones de 987654321. En los siguientes calculos si son numeros menores a nueve el calculo ya no se realizará por que el valor ya quedó guardado. Si es un número mayor a 9 solo se hara las operaciones a partir del numero, si es 11 el calculor sería: 1110362880.

wow…

este es mi factorial

<  function getFactorial(number){
          var tmp=1;
          for(let i=number;i>0;i--){
           tmp=tmp*i;
          }
          return tmp;
        }>

codigo JS clase44 Memoización pree

function factorial(n){
   
    if(!this.cache){
        this.cache = {}
    }

    if(this.cache[n]){
        return this.cache[n]
    }
   
    if(n ===1){
        return 1
    }

   this.cache[n] = n * factorial(n-1)
   
   return this.cache[n]


}

Memoización!

const factorial = n => {
  if(n < 0) {
    throw "Número no valido"
  }
  if (!this.cache) {
    this.cache = {0: 1, 1: 1}
  } 
  if (this.cache[n]) {
    return this.cache[n]
  }

  this.cache[n] = n * factorial(n - 1)
  return this.cache[n]
}

Muy interesante este detalle.

Lean sobre recursiones de cola, otra manera de optimizar el stack de llamadas de funciones recursivas.

buahh!!! me exploto la cabeza buenisimo, nunca habia escuchado eso de guardar viejos resultados de una funcion por si casualmente en un futuro se envian los mismos parametros

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Memoización en JS</title>
</head>

<body>
    <script>
        function factorial(numero) {
            if (!this.cache) {
                this.cache = {};
            }
            if (this.cache[numero]) {
                return this.cache[numero];
            }
            if (numero === 1) {
                return 1
            }
            this.cache[numero] = numero * factorial(numero - 1);
            return this.cache[numero];
        }
        console.log(`Resultado del factorial de Prueba es: ${factorial(6)}`);
    </script>
</body>
</html>

Hizo falta el caso de cuando es 0. Muy buen curso.

function factorial(numero) {

    if (!this.cache) {
        this.cache = {};
    }

    if(this.cache[numero]) {
        return this.cache[numero];
    }

    if (numero === 1 || numero === 0) {
        return 1;
    }

    this.cache[numero] = numero * factorial(numero-1);
    
    return this.cache[numero];
}

Excelente clase, JavaScript cada vez me deja con mas ganas de seguir aprendiéndolo.

buena clase

Excelente clase.

esto ya es otro nivel de tecnicas de desarrollo que nos alimentan para usar toda esta logica de forma transversal y acumulativa de conocimiento en otros lenguajes o habilidades

Aqui les dejo como seria escrito dentro del codigo hasta que consigue el resultado.

function factorial ( 6 ) {
	if ( 6 === 1 ) { //no sucede
		return 1 //este no sucede porque es factorial de 6
	}
	return 6 * factorial ( 6 - 1) {//iteracion con el numero 5 y hace el factoreal de 5 entrando en otro ciclo
		if ( 5 === 1 ) { //no sucede segunda iteracion
			return 1 
		}
		return 5 * factorial ( 5 - 1 ) { //iteracion con el numero 4  
			if ( 4 === 1 ) { //no sucede
				return 1
			}
			return 4 * ( 4 - 1 ) { //iteracion con el numero 3
				if ( 3 === 1 ) { //no sucede
					return 1 
				}
				return 3 * ( 3 - 1 ) { //iteracion con el numero 2
					if ( 2 === 1 ) { //no sucede
						return 1
					}
					return 2 * ( 2 - 1 ) { //iteracion con el numero 1
						if ( 1 === 1 ) { //Ahora si sucede
						return 1
						} // no se ejecuta la otra linea de codigo
					}
				}
			}
		}
	}
}```

Este metódo de combinar funciones recursivas con un guardado, hace mucho más eficiente el proceso, yo siempre me preguntaba como hacer las funciones recursivas mas efecientes y esta es una excelente forma.

function Factorial(numero) {
  if (!this.cache) {//Pregunta si existe una cache (memoria temporal).
    this.cache ={}//Declara la cache.
  }

  if (this.cache[numero]){//Se verifica si ya tenia el resultado previamente calculado.
    return this.cache[numero];//Se regresa el resultado
  }

  if (numero<2){
    return 1;
  }

  this.cache[numero] = numero * Factorial(numero-1)//Guarda en la cache antes de realizar el return.
  return this.cache[numero];//Regresamos el resultado.
}

Me está volando la cabeza la recursividad… Debería ponerme a estudiarla bastante

HOLAAAAA
function factorial(n){
    if(n < 0){
        return "Error: No estan permitidos valores negativos";
    }
    
    if(!this.cache){
        this.cache = {};
    }

    if(this.cache[n]){
        return this.cache[n];
    }

    if(n === 0){
       this.cache[n] = 1;
       return this.cache[n];
    }
    this.cache[n] = n * factorial(n - 1);
    return this.cache[n];

}

Me perdí en algunas cosas, pero no dejare que brote frustración, este lenguaje y esta escuela son increíbles! practicare y practicare !!

MIT STUFF

Muy buena explicacion de como funciona el factorial en prorgramacion. Justo en el clavo.

2. Memoización: ahorrando cómputo

Les comparto el código de esta clase, es muy interesante cómo se usa la cache:

function factorial(n) {
    if(!this.cache) {
        this.cache = {}
    }
    if(this.cache[n]) {
        console.log('Usando cache :3');
        return this.cache[n];
    }
    if (n === 1) {
        return 1;
    }
    this.cache[n] = n * factorial(n - 1);
    return this.cache[n];
}

Me encanto la parte del debugger, no tenía idea de que chrome tiene esta herramienta.

Gracias, Sacha

Memorización
Hay situaciones en las que un algoritmo puede generar que un mismo procedimiento se repita multiples veces. Para estas situaciones podemos generar un cache en el cual almacenar el resultado de estas funciones que posiblemente se repitan y necesitemos ese resultado.

Un ejemplo de esto se puede dar con un algoritmo de recusividad. En este caso el calculo de un factorial. En el cual creamos un objeto en un atributo del objeto windows (this), asignandole un nombre estrategico y antes de realizar el procedimiento verificamos si no ha sido guardado alli con anterioridad.

function CalculoFactorial(n)
{ 
    if(!this.cache)
    {
     debugger
      this.cache = {}
    }
   if(this.cache[n])
   {
     return this.cache[n]
   }
   if(n===1)
   {
     return 1;
   }else
   {
     debugger
       this.cache[n] = n * CalculoFactorial(n-1);
       return this.cache[n];
   }
}
console.log(CalculoFactorial(6));
console.log(CalculoFactorial(6));
console.log(CalculoFactorial(7));

Según lo que conozco, 0! = 1 y factorial solo está definido en los enteros positivos (no está definido en los negativos ni en decimales) Por lo que añadí unas cuantas cosas:

function factorial(n){
	n = parseInt(n)
    
		if(!this.cache){
        this.cache = {}
    }

    if(this.cache[n]){
        return this.cache[n]
    }
    
    if(n<0){
        return console.error('No hay factorial definido para numeros negativos')
    }
    
    if( n === 1 || n===0 ) {
        return 1
    } else {
        this.cache[n] = n * factorial(n-1)
        return this.cache[n]
    }
}  ```

Entiendo el punto pero una vez esa que se guarda en el cache y quieres usar la funcion con otro parametro esa funcion se vuelve inutil y te retorna NaN.

Solo me acorde de los casos de factoreo!

Muy buena clase.

Okay, entiendo como se obtiene un factorial, pero lo que no entiendo es ¿por qué en la seguda parte de la función la llama con el -1
retunr n * factorial ( n -1) ? Ese -1 no está de más???

En ocasiones los programas ejecutan algunas funciones o procesos múltiples veces, los valores o datos que obtenemos de estos podrían servirnos en el futuro, por lo que guardarlos para simplemente acceder a ellos en lugar de ejecutar codigo para volverlos a obtener cada que los necesitemos puede resultar muy útil.

wow, totalmente sin pies ni cabeza

buena clase

Bien explicado.

muy buena clase

haha un poco complejo

Como sacar el caso base, existe una formula para deducirlo?

Mis ideas claves junto a mi còdigo
IDEAS CLAVES

=> ¿Que es Memoizacion?

Memoizacionn es ahorrar procesamiento
ahorrar computo a travès de la caché

/*
Autor: Daniel Páez
URL Autor:  heysoypaez.com
Tema de la clase: Uso de la fecha en javascript
Descripción: Aprovechando el objeto Date() para hacer calculos conzz
URL código: github.com/heysoypaez
*/

/*
factorial de 6 es:

6*5*4*3*2*1
10 * 9 * 8 * 7 * 6*5*4*3*2*1

si calculamos el factorial de 12 tambien estamos calculando en factorial de 6



nuestro caso base es 1
*/





/*PROTOCOLO DE VERIFICACIÓN DE FUNCIONAMIENTO
==================================*/
//Imprimiendo algo en la consola
console.log("inicializando archivo");


/*DECLARACIÓN DE OBJETOS
============================*/		

/*DECLARACIÓN DE VARIABLES
==================================*/
const valorUsuario = prompt("¿Cual es el nùmero del factorial?")

//Variables de la funcion factorial
let numero


/*DECLARACIÓN DE FUNCIONES
========================================================*/


function factorial(numero) {

	//cada funcion puede tener atributos internos tambien
	if (!this.cache) {
		//si no hay una cache de esta funcion, creala
		this.cache = {}
	}

	debugger
	
	if (this.cache[numero]) {
		//si ya hay en la cache un numero lo retornamos y listo papá
		return this.cache[numero]
	}

	// caso base
	if (numero === 1){
		return 1
	}

	// caso recursivo
	this.cache[numero] = numero * factorial(numero - 1)	
	//guardando en cache el numero

	debugger

	return this.cache[numero]
	
}



/*EJECUCIÓN DE FUNCIONES Y PROMESAS
========================================0*/
console.log( factorial(valorUsuario) )

Esto sirve para guardar datos de manera temporal o no ?

un buen caso para pensar en la memoization es para encontrar el numero de fibonacci ya que en la funcion se llama dos veces la misma funcion guardando el la primera iteracion

La Pagina tiene problemas con opera para reproducir video 😕

function factorial (n) {
	var total = 1; 
	for (i=1; i<=n; i++) {
		total = total * i; 
	}
	return total; 
}
function factorial(n) {
	if (!this.cache) {
		this.cache = {};
	}

	if (this.cache[n]) {
		this.cache[n];
	}

	if (n === 1) {
		return 1;
	}
	this.cache[n] = n * factorial(n - 1);
	return this.cache[n];
}
lkmjnhbgfdre```

Los clásicos de estructura de datos jeje

Me encanto esta clase, La tuve que repetir varias veces y practicar para poder entender. Gracias por esta clase y vamos por más.

increible!

No es muy claro esto de la memoizacion .

Gracias, por la clase. Honestamente, la repetí hasta que, lo pude realizar por mi cuenta.

El codigo lo entiendo pero hay una hecho que ocurre en el debugger de chrome en la instrucción return this.cache[n]. El debugger se queda recorriendo este return 6 veces si has hecho factorial(6) o mejor dicho hace tantos recorridos como el numero de factorial. ¿A Que es debido este comportamiento?

 function factorial(n) {
         if (!this.cache) {
           this.cache = {}
         }
         debugger
         if (this.cache[n]) {
           return this.cache[n]
         }
         if ( n === 1 ) {
           return 1
         } else {
           this.cache[n] = n * factorial(n - 1)
           debugger
           return this.cache[n]
         }
       }
function factorial(numero) {
  debugger

  if(!this.cache){
    this.cache = {}
  }
  if(this.cache[numero]){
    return this.cache[numero]
  }
  if(numero===1){
    return 1
  }

  this.cache[numero] = numero * factorial(numero-1)
  return this.cache[numero]
}

Suma sucesiva de los ‘n’ primeros números

const SumaSucesiva = (numero) => {
  if(!this.Memoria){
    this.Memoria = {1: 1}
  }

  if(this.Memoria[numero]){
    return this.Memoria[numero]
  }

  if(numero===1){
    return 1
  }

  this.Memoria[numero] = numero + SumaSucesiva(numero-1)
  return this.Memoria[numero]
}

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Clase 45 - Memoización: ahorrando cómputo</title>
</head>

<body>
    <script>
        function factorial(n) {
            if (!this.cache) {
                this.cache = {};
            }

            if (this.cache[n]) {
                return this.cache[n];
            }

            if (n === 1) {
                return 1;
            }

            this.cache[n] = n * factorial(n - 1);
            console.log(this.cache[n]);
            return this.cache[n];
        }

        console.log(factorial(5));
    </script>

</body>

</html>

no sabia que este tema se llamaba de esta forma excelente clase me gusto mucho

Me exploto la cabeza al principio, pero viéndolo bien resulta ser muy útil guardar un valor en la memoria para luego usarlo posteriormente por ejm si quisiéramos calcular el factorial de 8 pero previamente ya habíamos guardado el factorial de 5 entonces ese proceso costaría menos recursos porque solo seria 876*5!

Este tema esta algo complejo

Un tanto complejo, pero bastante interesante, habrá que indagar más en el tema y si realmente es usado en el mundo laboral 😃

La clase es muy buena y entiendo como se usa el almacenamiento en la cache, pero sigo teniendo un poco de dudas con el debugger , si alguien sabe un poco mas a profundidad agradecería que me lo explicara

Buena forma de optimización.


const factorial = (numero) => {
    console.log('Inicio  ', new Date().getTime())
    if (numero === 1) {
        return numero
    }
    if (!this.cache) {
        this.cache = {}
    }
    if (this.cache[numero]) {
        console.log('FinCache', new Date().getTime())
        return this.cache[numero]
    }
    this.cache[numero] = numero * factorial(numero - 1)
    console.log('Fin     ', new Date().getTime())
    return this.cache[numero]
}

Y acá comparto los resultados para factorial(24)

Excelente clase, muy clara.

Increíble!!!

Excelente curso. Me está estallando la cabeza. A seguir practicando jaja. 🙂

Genial!

Esto es un tema importante muchas veces se nos olvida que podemos optimizar nuestro código.

Un tema muy interesante, pero lastima que no se pueda usar en producción por temas de rendimiento. Aun así nunca esta de mas saberlo o recordarlo.

        function factorial (n) {
            if (!this.cache) {
                this.cache = {}
            }

            debugger
            if ( this.cache[n]) {
                return this.cache[n]
            }

            if (n  === 1) {
                return 1 
            } else {
                this.cache[n] = n * factorial(n - 1)
                debugger
                return this.cache[n]
            }
        }

hola no se porque me aparece este error!!! alguien sabe??

Uncaught TypeError: Cannot read property ‘3’ of undefined
at factorial (memorizacion.html:24)
at memorizacion.html:39

    function factorial(n)
    {
        //Preguntamos si existe un cache,
        if(!this.cache)//preguntamos si la cache esta definida o no
        {//si no esta definida creamos un objeto nuevo vacio
            this.chache = {};
        }
        
        if(this.cache[n]) //Preguntamos si la operacion con n ya existe y si ya existe la calculamos
        {
            return this.cache[n]
        }

        if(n===1)
        {
            return 1;
        }

        this.cache[n] = n * factorial(n-1)
        //debugger //debugger para ver como se comporta la funcion
        //la n va guardando el valor
        return this.cache[n];
    }
    factorial(3);

Primera vez que veo este concepto, muy bueno

El factorial máximo antes de retornar infinito es 170

Muy interesante el tema de la Memoización.
Pregunta: ¿Cómo se borra la caché?

Implementación del ciclo FOR

  for (var i = 1; i <= 10; i++)
      {
        document.write(`Este es el factorial de ${i}: ${factorial(i)}<br></br>`)
      }```

Que buena clase!!

XD
Yo en el intento de plantear la función factorial (sin ver el video dos veces) cree una función que guarda en cache solo el valor del ultimo numero factorial (n) que se ingresa ^^!
(guardando este valor y su ‘n’ para reutilizar solo si se calcula un numero factorial igual o mayor)
repl.it/@alvarohrv/funcionFactorial2Modelos
Nota: a diferencia de la función del profesor que guarda en forma de atributos el valor de cada número factorial

Excelente!!

excelente ejemplo, muy utili en la generacion de reportes.

        /*
        !6 = 6 * 5 * 4 * 3 * 2 * 1
        !12 = 12 * 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
        */

            function factorial(n) {
                if(!this.cache) {
                    this.cache = {}
                }

                if (this.cache[n]) {
                    return this.cache[n]
                }

                if (n === 1) {
                    return 1
                }

                this.cache[n] = n * factorial(n - 1)
                return this.cache[n]
            }

Bastante interesante este tema.

Interesante!!! En verdad me gusto esta clase