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

Funciones recursivas

51/55
Recursos

La recursividad es un concepto muy importante en cualquier lenguaje de programación. Una función recursiva es básicamente aquella que se llama (o se ejecuta) a sí misma de forma controlada, hasta que sucede una condición base.

Aportes 122

Preguntas 9

Ordenar por:

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

Acá tengo una pregunta para todos ya que llevo trabajando en informática por mas de 10 años y muchos de los proyectos en los que he trabajado han sido para entidades bancarias, financieras y para entidades gubernamentales en las cuales se manejan una inmensa cantidad de información y jamas JAMAS he visto una función recursiva en el código que me ha tocado revisar, e incluso cuando me ha tocado desarrollar se me ha especificado el no usar recursividad, y esto es debido que a mayor cantidad de iteraciones estas funciones bajan muchísimo la performance de las aplicaciones. Por lo mismo he llegado a considerar la recursividad solo como un lindo ejercicio de lógica. Aun así resulta útil cuando las iteraciones se saben pocas. Lo que me gustaría saber es ¿Cual ha sido vuestra experiencia con este tipo de solución?

18 años estudiando para que Sacha me enseñe a dividir de nuevo jaja eres un crack

Resumen de la Clase
Funciones Recursivas

Para realizar recursividad necesitamos 2 cosa; 1 caso base y 1 caso recursivo.
Usaremos una división para mostrar las funciones recursivas.

Algoritmo de nuestro ejercicio:

13 /4_

13 - 4 = 9 1 => caso recursivo
9 - 4 = 5 1 => caso recursivo
5 - 4 = 1 1 => caso recursivo
1 - 4 = -3 0 => caso base

La función:


function divisionEntera(dividendo, divisor) {
	if (dividendo < divisor) {
		return 0
	}
	return 1 + divisionEntera(dividendo - divisor, divisor)  
}

dividendo - divisor’ en el primer parámetro de nuestra función recursiva invocada dentro de sí misma sería el ‘caso recursivo’ que se repetirá mientras la condición no se cumpla. Cuando la función se cumple, ‘caso base’ termina la recursividad, termina la operación y nos entrega el resultado de la división en valor entero.

Todos hablando de lo bonito que es la recursividad, pero nadie habla de la pila.

Uncaught RangeError: Maximum call stack size exceeded

like (y) si te enseñaron la recursividad con el factorial de un numero jejeje

Una función recursiva es básicamente aquella que se llama (o se ejecuta) a sí misma de forma controlada, hasta que sucede una condición base.

me vuela la cabeza la recursividad, es como la pelicula inception

Por acá dejo una herramienta super buena que me encontré hace poco y que facilita mucho el trabajo con JS.
Espero sea de utilidad.
https://quokkajs.com/

Un caso típico de recursión es cuando queremos renderizar una matriz con una estructura anidada o de árbol, por ejemplo consideren el siguiente ejemplo:

const items = [
    {
        item: 'item-1',
        level: 1,
        subItem: [
            {
                item: 'item-1.1',
                level: 2,
                subItem: [
                    {
                        item: 'item-1.1.1',
                        level: 3,
                        subItem: [
                            {
                                item: 'item-1.1.1.1',
                                level: 4,
                                subItem: []
                            }
                        ]
                    }
                ]
            },
            {
                item: 'item-1.2',
                level: 2,
                subItem: []

            }
        ]
    },
    {
        item: 'item-2',
        level: 1,
        subItem: [
            {
                item:'item-2.1',
                level: 2,
                subItem: []
            }
        ]
    }
]


function printItems(items) {
    items.forEach(({ item, subItem, level }) => {
        console.log(`${(new Array((level - 1) * 5 ).join(' '))}${item}`);
        if (subItem.length > 0) {
            printItems(subItem);
        }
    });
}

printItems(items);

La salida de este código es:

Es muy clara la explicación de Sacha. Me gustaría que Platzi hiciera un curso de Programación funcional, ya que se aplica por completo las funciones recursivas.

Estuve indagando sobre la recursividad en JS y entre varios lugares encontré este que me pareció bastante gráfico:
https://code.tutsplus.com/es/tutorials/understanding-recursion-with-javascript--cms-30346

ok, entendí la clase, pero no entendí para que sirve realmente, en la practica.

Con Math.floor hacemos lo mismo y con menos lineas.

???

Buen refresco de funciones recursivas, un punto fundamental es que el uso de recursos es significativamente menor cuando se hace uso de recursividad para una tarea, dejo mi ejercisio de practica, implementando el problema de esta clase y adicionalmente el uso de recursividad para calcular el modulo o el residuo de la division entera

//Modulo (residuo de una division entera)
//Devuelve el residuo resultado de una division entera dados el diviendo y el divisor
function residuoDivisionEntera(dividendo, divisor){
    if(dividendo < divisor){
        return dividendo;
    }
    else{
        return residuoDivisionEntera(dividendo - divisor, divisor);
    }
}

//Division entera
//Devuelve el residuo resultado de una division entera dados el diviendo y el divisor
function divisionEntera(dividendo, divisor){
    if(dividendo < divisor){
        return 0;
    }
    else{
        return 1 + divisionEntera(dividendo - divisor, divisor);
    }
}

console.log(divisionEntera(9,3));
console.log(residuoDivisionEntera(9,3));

Tuve que escribirlo en papel para entenderlo un poco mejor ^_^;

hola, quiero saber como mejorar la lógica. ya que nada me sale cuando los hago yo, pero cuando los copio entiendo. soy nueva llevo poco tiempo y le agradezco su aporte

Esto es demasiado importante, ahorra mucho trabaj al programador a la máquina.

Me gustaria hacer un aporte por si alguien le sirve como ejemplo tenerlo aparte del ejemplo de Sascha:

    <script>

function ftl(n){
    if ( n ===1){
        return 1
    }
    return n * ftl(n-1)
}
console.log(ftl(3))

//Lo que ocurre por dentro de la funcion (Ella misma se autofinaliza). Lo importante de esto es que tenga un fin
//y no ocurra un bucle

//flt(3) -> (3 * ftl(2))
//flt(2) -> (2 * ftl(1))
//flt(1) -> 1

//so, ftl(3) return (3*(2* (1)))
//which is 6.

    </script>```

como ya lo mecionaron la recursividad no es recomendable en ningun lenguaje de programacion porque hace a los programas mas lentos

¿En qué casos es mejor usar recursividad?

jajaj nunca se me había ocurrido dividir asi, es decir si había escuchado que dividir era una forma de restar rapido al igual que sumar rapido es una multiplicación pero jamás lo habia visto en vivo y en direct xD

código JS clase 43 —> Funciones recursivas

function divisionEntera(dividendo,divisor){

    if(dividendo <divisor){
        return 0
    }
    return 1 + divisionEntera(dividendo-divisor,divisor)

}

El mismo codigo

¯\_(ツ)_/¯

         function divisionEntera(dividendo, divisor) {
             if (dividendo < divisor) {
                 return 0
             } 
             return 1 + divisionEntera(dividendo - divisor, divisor)
         }
function divisionEntera(dividendo , divisor) {
  if(dividendo < divisor){
    return 0
  }
  return 1 + divisionEntera(dividendo-divisor,divisor)
}

He hecho recursividad pero para un factorial

function Factorial(numero) {
  if(numero===0){
    return 1
  }
  return numero * Factorial(numero-1)
}

Muy buenas,

Con el objetivo de poder implementar funciones recursivas que no bloqueen el EventLoop, ¿tiene algún sentido plantear la resolución de la función con promesas?. Si no lo he entendido mal, esto haría que cada iteración del EventLoop únicamente se ejecute una iteración del algoritmo, ¿cierto?

Les paso un ejemplo a ver que opinan:

function divisionEntera(dividendo, divisor, acum = 0) {
	return new Promise((resolve, reject) => {
		if (dividendo < divisor) {
			return resolve(acum);
		} else {
			return resolve(divisionEntera(dividendo - divisor, divisor, acum + 1));
		}
	});
}
divisionEntera(53, 4).then(val => console.log(val));

el return acumula de cierta forma como una variable el resultado??

Excelente video para explicar la recursividad. Me encantó cuando hacen un ejemplo cotidiano al inicio, en este caso 13 dividido 4 (como se hacia en la escuela), y luego pasan ese ejemplo a código, ojalas sigan haciendo videos así, es lo mejor.

La recursividad es un concepto muy importante en cualquier lenguaje de programación. Una función recursiva es básicamente aquella que se llama (o se ejecuta) a sí misma de forma controlada, hasta que sucede una condición base.

Yo lo hubiera hecho de esta forma:

function divisionEntera(dividendo, divisor) {
	let contador = 0
	let resta = dividendo

	while(resta >= divisor){
		resta -= divisor
		contador++
	}
	console.log(`La division entera ${dividendo} / ${divisor} es ${contador}`)
}

divisionEntera(13, 4)

Alguien me puede explicar cual de las formas es mas optima y por qué?

Gracias!

Comparto algunos ejemplos adicionales de funciones recursivas:

// FUNCIONES RECURSIVAS
function division(dividendo, divisor) {
  if (dividendo < divisor) {
    return 0;
  }
  return 1 + division(dividendo - divisor, divisor);
}

function multiplicacion(factor1, factor2) {
  if (factor1 === 0 || factor2 === 0) {
    return 0;
  }
  return factor1 + multiplicacion(factor1, factor2 - 1);
}

function sumatoria(num) {
  if (num === 0) return 0;
  return num + sumatoria(num - 1);
}

function factorial(num) {
  if (num === 0) return 1;
  return num * factorial(num - 1);
}

En toda Universidad te toman la funciónes Recursiva con el número factorial:

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

Pura logica, y cuando se llega a cabo poco a poco se produce una sensacion de placer en el crebro.
Conclusion, solucionar problemas logicos a tu manera es un caramelo para tu cerebro hahaha

hola a todos , alguien por casualidad sabe por que en la funcion recursiva , mas exactamente en la parte de
return 1 + divisionEntera (dividendo - divisor , divisor) por que nuevamente se pide el divisor? en esta linea ? gracias por su respuesta.

Que grande sacha, excelente explicacion de la recursividad y gran clase de como dividir jajaj. Nos vemos en la cocina, crack!!

No es recomendado usar recursividad, pues el rendimiento de las aplicaciones baja bastante, esto lo he podido comprobar en mi trabajo en varias aplicaciones con varios lenguajes, al hacer tunning del codigo y reemplazar por instruicciones iterativas el cambio es bien notorio, la perfomance de las aplicaciones se incrementa.

Hola la función de Sacha:

const div_ent = (dd, dv) => dd < dv ? 0 : 1 + div_ent(dd - dv, dv) 

los máximos que acepta la consola de chrome son:

div_ent(28958, 3)
9652
div_ent(19304, 2)
9652 

con un numero mayor arroja:
Maximum call stack size exceeded

Funciones Recursivas

/*
13 /_4___

13 - 4 = 9  1 CASO RECURSIVO
9  - 4 = 5  1 CASO RECURSIVO
5  - 4 = 1  1 CASO RECURSIVO
1  - 4 = -3 CASO BASE

*/

function intDivision(dividend, divisor) {
    if (dividend < divisor) {
        return 0
    }

    return 1 + intDivision(dividend - divisor, divisor)
}

Para realizar la recursividad se necesitan 2 cosas:

  • Caso base: Es el último caso para finalizar la función o el ciclo
  • Caso recursivo: Es el caso que va a iterar hasta ser controlado por el caso base

Aporte compañero

Una función recursiva es básicamente aquella que se llama (o se ejecuta) a sí misma de forma controlada, hasta que sucede una condición base.

que implicaciones tendría usar recursividad en nuestro código, podría gastar mucha memoria, en que casos es recomendable hacerlo?

(Que bueno esto de la recursividad =) mensaje para mi hermosa esposa) =>

Muy interesante sobre todo la división.

La importancia del caso base es que permite que la recursividad termine, porque puede continuar infinitamente.

Esta clase de 6 minutos resumió todp un tema de 1 mes de mi universidad. GG Sacha

Muy bien explicado para lograr entender la recursividad

muy buenas clases

Muy interesante 😃

Eso del caso base esta bueno

IDEAS CLAVES

=> ¿Que es recursividad?
Una función recursiva es básicamente aquella que se llama (o se ejecuta) a sí misma hasta que sucede una condición base.

=> ¿Para que me sirve? ¿Como lo puedo utilizar?
Para ejecutar de algun modo ciclos a traves de funciones

/*
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
*/

/*Pseudocodigo de mi programa

	15 |_4____

15 - 4 = 11 1
11 - 4 = 7 1
7 - 4 = 3 1
fin

mientras el dividendo sea mayor o igual que el divisor restamos

*/




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



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

function divisionEntera(dividendo, divisor) {

	/* La recursividad implica dos cosas
	un ca,so base y un caso recursivo

	*/
	let i = 0;
	let casoBase = dividendo < divisor
	/*Caso base es cuando el diviendo es menor que el divisor*/

	if(casoBase) {
		return 0
	}
	
		return 1 + divisionEntera(dividendo - divisor, divisor)
	

}

/*EJECUCIÓN DE FUNCIONES Y PROMESAS
========================================0*/

console.log(divisionEntera(400, 12))

/*=======================================
RENDER EN PANTALLA
Agregando al html datos de la clase
=======================================*/

//Variables
let temaClase = "Funciones recusirvas";
let titulo = document.getElementById("title")
let contenidoClase = document.getElementById("contenido-clase")

//Variables reasignadas
titulo.innerHTML=  temaClase;
contenidoClase.innerHTML= temaClase;

//contenido de la clase

let apuntes = document.getElementById("apuntes")
let textoContenido = " " 

apuntes.innerHTML = `${textoContenido}`;

/*
===============================================================================



Control de errores
-----------------
//
------------------------------
===================================================================================================================== 
*/

function divisionEntera (dividendo, divisor) {
  if (dividendo < divisor) {
    return 0
  }
  return 1 + divisionEntera(dividendo - divisor, divisor) // retorna 3
  // 3 son las 3 veces que se ejecuto la funcion recursiva
}

console.log(divisionEntera(13, 4))

Ejemplo de función recursiva.

Muy buena clase.

Recursividad

Recursividad

Muy Bien Explicado.!! 😃

Un ejemplo un poco más interesante

// ====   Ejemplo de recursividad , Tree ====
/**
 *  Se basa en que un objeto Tree tiene como propiedad una lista
 *  ya sea de nodos instancias de Tree ó números, y el total 
 *  de la suma de dichos números y de cada nodo 
 * 
 *                  Tree
 *                 /  \  \ 
 *              Tree Tree  lista
 *             |       |         \
 *            lista   lista      [1,2,3]
 *           [1,2,3]  [1,2,3]                      
 * 
 *  El resultado seria 18
 */

class Tree{
    
    
    constructor(){
        this.leaf = new Array();    
        this.total= 0;
    }

    isATree(node){        
        if(node instanceof Tree){
            return true
        }

        return false;
    }

    countLeaf(leafs){        
       return leafs.reduce((a,b)=> a+b, 0);
    }

    getTotal(tree){        
        this.total = 0;        

        for (let i = 0; i < tree.leaf.length; i++) {
            const element = tree.leaf[i];
            
            if(this.isATree(element)){

              this.total += this.getTotal(element);

            }else if(element.length > 0){
               this.total += this.countLeaf(element);
            }else{
              this.total += element
            }

        }

       return this.total;
    }


    printTotal(){
        console.log(this.total);
    }

}



tree1 = new Tree();
tree2 = new Tree();
tree3 = new Tree();

tree1.leaf.push(1,2,3);
tree2.leaf.push(1,2,3);
tree3.leaf.push(1,2,3);

tree1.leaf.push(tree2,tree3);


tree1.getTotal(tree1);
tree1.printTotal();

excelente

😮

Excelente, ya era hora de revisar un ejemplo de recursividad

Definitivamente explotó mi cabeza con la recursividad jajaja… está genial.

A mi modo de ver, entender y saber aplicar la recursividad es super importante en programación (independiente del lenguaje que uses)

Genial la recursividad

creo que la recursividad en cualquier lenguaje de programación es lo más complicado, porque requiere mucha practica…

function division_entera(dividendo, divisor) {
	if (dividendo < divisor) {
		return 0;
	} else {
		return 1 + division_entera(dividendo - divisor, divisor);
	}
}

Yo habia escuchado algo de que las divisiones eran como restas con superpoderes y la multiplicacion sumas con superpoderes. Ahora veo a que se referían Guuuoouuuu.

Creo sino estoy mal los algoritmos de ordenamiento en el lenguaje C funcionan con recursividad algoritmos eficientes con tiempos de complejidad Big O eficientes como el (quick sort) asi que siento que la recursividad es muy util en determinados casos o tambien podemos freezear la memoria usando recursividad

Aquí un poco de código comprimido, no es recomendable por que no es fácil de leer pero para practicar esta bien.

let divicionEntera = (dividendo, divisor) => (dividendo < divisor)? 0 : 1 + dividirNumero(dividendo - divisor, divisor);

Una observación, de acuerdo al ejercicio se debe utilizar la terminología de la sustracción o resta, el minuendo es el número al que se le quitan unidades y el sustraendo es el número que se le resta

Le agregue para ver el residuo

function divisionEntera(dividendo, divisor) {
	if (dividendo < divisor) {
		const residuo = divisor + (dividendo - divisor)
		console.log(`El residuo es ${residuo}`)
		return 0
	}
	return 1 + divisionEntera(dividendo - divisor, divisor)
}

Increíble!

Sorprendente esta clase .

<!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 44 - Funciones recursivas</title>
</head>

<body>
    <script>
        function divisionEntera(dividendo, divisor) {
            if (dividendo < divisor) {
                return 0;
            }
            return 1 + divisionEntera(dividendo-divisor,divisor);
        }

        console.log(divisionEntera(26, 4));
    </script>

</body>

</html>

Un gran caso de la programacion funcional

¿y cómo le hago si tengo que repetir una acción infinita? … es decir, un slider automático

/*
13 /____4___

13 - 4 = 9      1
9 -  4 = 5      1
5 -  4 = 1      1
1 -  4 = -3     0
________________________
                3
*/
function divisionEntera(dividendo, divisor){
    if (dividendo < divisor){
        return 0;
    }
    return 1 + divisionEntera(dividendo - divisor, divisor);
}```

Esto de la recursividad lo vi en python con el ejemplo de un factorial, pero por lo que leo los comentarios anteriores, no se aplica en la vida real.

La función recursiva se llama así misma de forma controlada hasta que se cumpla una condición base.

Bueno saberlo, pero no se recomienda el uso de estas funciones debido a que bajan el rendimiento(en el caso de funciones más complejas), pero nunca está demás saber que están allí para su uso 😃

Muy interesante el concepto de recursividad

    function entireDivision(up, down){
        if(up<down){
            return 0
        }
        else{
            return 1 + entireDivision(up-down, down)
        }
    } 

Explicación clara y buen ejemplo

function divisionEntera (dividendo, divisor) {
            if (dividendo < divisor) {
                return 0
            } else {
                return 1 + divisionEntera(dividendo - divisor, divisor)
            }
        }

//Funciones recursivas

/* División Entera 13/4

    Dividendo = 13
    Divisor = 4

    13 - 4 = 9      Contador = 1
    9  - 4 = 5      Contador = 2
    5  - 4 = 1      Contador = 3
    1  - 4 = -3     Se termina 
*/

function dividir (dividendo, divisor){
    //Se pone una condición BASE: es la que permite terminar la función
    if (dividendo-divisor <0){
        return 0;
    } else {
        return 1 + dividir(dividendo-divisor,divisor)
    }
}```

Tiene un bug la funcionalidad debido a que el residuo si es 0 se debe considerar dentro del contador, en este caso me di de cuenta con esta división 12/2, si no se considera el 0 daría recursividad de 5 y es de 6

este es mi código

<  <script>

    function  recursividad(divisor,dividiendo){

      let contador=1;
      let state=true;
      let start=true
      let residuo=0;

      while(state) {
        if(start){
          residuo = parseInt(divisor-dividiendo);
        } else {
            residuo = parseInt(residuo-dividiendo);
        }

       state=checkResiduo(residuo,dividiendo)

        if(state){
          start=false
          contador++;
        }
      
      }
      return contador;
     }

      function checkResiduo(residuo,dividiendo){
        return residuo-dividiendo>=0
      }

    </script>>

En qué casos es común encontrarlas?

¿Los ciclos serían recursivos? ¿Cierto?

aprendiendo, buena clase, a continuar con el curso

Excelente la recursividad

Interesante el tema.

Muy interesante a seguir investigando sobre este tema

Interesante la clase, imagino que hay un sin números de algoritmos para diferentes casos donde hay un problema.

ok!

😮 genial!!!

La recursion es muy interesante para poder resolver un problema con recursion el problema cumplir 2 puntos.

  1. el problema debe tener un “caso base” es un punto donde no se puede dividir mas el problema. ejemplo el caso base en el factorial es: !0 = 1 en este punto se acaban las rucurciones.

  2. Que el problema pueda ser resuelto por la resolución mediante de la resolución de problemas mas pequeños del mismo problema. Ejemplo: el factorial de 5 es igual a 5 * !4 * !3* !2 * !1 * !0

Interensante

function sum(num){
    if (num === 0) {
        return 0;
    } else {
        return num + sum(--num)
    }
}

sum(4) //10

Esto es lo que ocurre en cada paso:

Ve a sum(4).
¿4 es igual a 0? No. Coloca a sum(4) en espera y ve a sum(3).
¿3 es igual a 0? No. Coloca a sum(3) en espera y ve a sum(2).
¿2 es igual a 0? No. Coloca a sum(2) en espera y ve a sum(1).
¿1 es igual a 0? No. Coloca a sum(1) en espera y ve a sum(0).
¿0 es igual a 0? Sí. Evalúa sum(0).
Retoma sum(1).
Retoma sum(2).
Retoma sum(3).
Retoma sum(4).

Tomado de: https://code.tutsplus.com/es/tutorials/understanding-recursion-with-javascript--cms-30346

//division entera con recursividad
function divisionEntera(a, b, resultado){
if(a-b < 0){
return resultado
}else{
return divisionEntera(a-b, b, resultado+1)
}
}
var algo = divisionEntera(25,4,0)//dividendo, divisor, numero inicial
console.log(algo)

Muy buena clase.

Muy muy buena clase

no me acordaba como se dividia jajaja

recursivity == cool

<!DOCTYPE html>
<html lang="en" dir="ltr">
  <head>
    <meta charset="utf-8">
    <title></title>
  </head>
  <body>
    <script type="text/javascript">

    /*

    13  dividido entre 4

    13 - 4 = 9        1
    9 - 4 = 5         1
    5 - 4 = 1         1 
    1 - 4 = -3        0

    */
      function divisionEntera(dividendo, divisor){
        if (dividendo < divisor){
          return 0
        }

        return 1 + divisionEntera(dividendo - divisor, divisor)
      }

    </script>

  </body>
</html>

function divisionEntera(dividendo, divisor) {
            if (dividendo < divisor) {
                return 0
            }else {
                return 1 + divisionEntera(dividendo - divisor, divisor)
            }
        }
        let cuanto = divisionEntera (400,4)
        console.log(cuanto)

Estupenda clase instructor Sacha, tendré en cuenta la recursividad al momento de ver si se pueden hacer más eficientes los métodos de un proyecto y si es permitido por los estándares de la empresa.