Introducción
¿Qué hay dentro de los objetos en JavaScript?
Profundicemos en los objetos
Static: atributos y métodos estáticos en JavaScript
Métodos estáticos del prototipo Object
Object.defineProperty
Cómo copiar objetos en JavaScript
Cómo funciona la memoria en JavaScript
Shallow copy en JavaScript
Qué es JSON.parse y JSON.stringify
Recursividad en JavaScript
Qué es recursividad
Deep copy con recursividad
Playgrounds: Hacer freeze de un objeto de forma recursiva
Abstracción y encapsulamiento sin prototipos
Factory pattern y RORO
Abstracción con objetos literales y deep copy
Module pattern y namespaces: propiedades privadas en JavaScript
Getters y setters
Cómo identificar objetos
Qué es duck typing
Duck typing en JavaScript
Instance Of en JavaScript con instancias y prototipos
Atributos y métodos privados en prototipos
Creando métodos estáticos en JavaScript
Próximos pasos
¿Quieres más cursos de POO en JavaScript?
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
La recursividad es cuando una función se llama a sí misma y esta genera una nueva ejecución de la función. Esto sucede reiteradamente hasta que cumpla o no con cierta validación que nosotros declaremos para que deje de llamarse a sí misma en algún punto.
Normalmente, pensaríamos que este tipo de problemas lo podemos resolver con condicionales y/o bucles. Veamos el siguiente ejemplo:
// PROBLEMA:
// Deseamos imprimir una serie de números desde el 0 hasta n números. En este caso
// hasta el 4
let numerito = 0; // Declaramos desde el número que deseamos partir.
// Usamos un bucle while para repetir este proceso hasta que se cumpla la condición:
while(numerito < 5) {
console.log(numerito);
numerito++;
}
Así resolveríamos este problema con recursividad:
// Función recursiva:
function recursiva(numerito) { // Recive un número
console.log(numerito); // Imprimimos en consola el número
if (numerito < 5) { // Evalua si es menor a 5
// Llamamos nuevamente a nuestra función enviandole el número siguiente:
return recursiva(numerito + 1);
} else { // La función deja de llamarse a sí misma:
return 5;
}
}
Empleemos ahora la recursividad para poder aplicar el Deep Copy en JavaScript y así copiar de manera óptima nuestros objetos. 🤓💪
Contribución creada por: Martín Álvarez (Platzi Contributor) con el aporte de Carlos Mazzaroli.
Aportes 81
Preguntas 7
🐦 Si quieren divertirse con la recursividad en Twitter: https://twitter.com/freddier/status/1432713290942144519
La recursividad es muy bonita para desarrollar el pensamiento lógico y computacional. La primera vez que tuve mi acercamiento con la recursion me explotó la cabeza jajaj
.
Ya luego te das cuenta que casi todo lo que logras con recursion lo puedas hacer mucho mas rápido con ciclos y bastante mas liviano en temas de esfuerzo para el procesador.
[“✌”,“😂”,“😝”,“😁”,“😱”,“👉”,“🙌”,“🍻”,“🔥”,“🌈”,“☀”,“🎈”,“🌹”,“💄”,“🎀”,“⚽”,“🎾”,“🏁”,“😡”,“👿”,“🐻”,“🐶”,“🐬”,“🐟”,“🍀”,“👀”,“🚗”,“🍎”,“💝”,“💙”,“👌”,“❤”,“😍”,“😉”,“😓”,“😳”,“💪”,“💩”,“🍸”,“🔑”,“💖”,“🌟”,“🎉”,“🌺”,“🎶”,“👠”,“🏈”,“⚾”,“🏆”,“👽”,“💀”,“🐵”,“🐮”,“🐩”,“🐎”,“💣”,“👃”,“👂”,“🍓”,“💘”,“💜”,“👊”,“💋”,“😘”,“😜”,“😵”,“🙏”,“👋”,“🚽”,“💃”,“💎”,“🚀”,“🌙”,“🎁”,“⛄”,“🌊”,“⛵”,“🏀”,“🎱”,“💰”,“👶”,“👸”,“🐰”,“🐷”,“🐍”,“🐫”,“🔫”,“👄”,“🚲”,“🍉”,“💛”,“💚”]
En una optativa de la carrera, vi programación funcional con haskell. En ese lenguaje los bucles no existen, por lo tanto, la única forma de hacer iteraciones era usando recursividad. Fue estresante, pero muy divertido.
Por si les interesa saber que patricio dejo de ser recursivo, minuto 6:25 sale el patricio que decidio no ser recursivo JAJAJA
Creo que la recursividad solo se deve usar en casos especificos, para lo demas prefiero usar iteraciones con ciclos de repeticon.
Es cuando una función se llama a sí misma. Tenemos que tener un caso base para que esta función se detenga.
Ejemplo básico con TypeScript:
function recursiva(){
if(/*validacion*/){
// llamados recursivos
} esle {
// llamados normales, sin recursividad
}
}
function recursiva(numerito: number): number {
console.log(numerito);
if (numerito < 5) {
return recursiva(numerito + 1);
} else {
return 5;
}
}
recursiva(0);
function recursiva(numbersArray: number[] | string[]): void {
if (numbersArray.length !== 0) {
const firstNum = numbersArray[0];
console.log(`first number: ${firstNum}`);
numbersArray.shift(); //* elimina el primer elemento del array
recursiva(numbersArray);
}
}
recursiva([9,8,7,6,5,4,3,2,1]);
recursiva(['😎','🤩','😜','🤑']);
También comparto este artículo: ¿Cuándo usar recursividad
Lo malo de la recursividad es que es exponencial, vs un ciclo en tiempos pierde siempre, aunque es muy bonita su implementación.
Me gusta la recursividad por que con 4 lineas de codigo puedo romper mi navegador.
Recursividad es una técnica de programación que consiste en que una función se llama a sí misma y crea una nueva ejecución de nuestra función
let numero = 0;
while(numero < 10){
console.log(numero);
numero++;
}
en recursividad sería_
function recursiva(numero){
console.log(numero);
if(numero < 5){
return recursiva(numero + 1);
}else {
return 5;
}
}
function recursiva(){
if (/* validación */){
//llamados recursivo
}else {
//llamados normales, sin recursividad
}
}
un ejemplo en recursivo sería así:
function recursiva(numbersArray){
if(numbersArray.length != 0){
const firstNumber = numbersArray[0];
console.log(firstNumber);
numbersArray.shift();
return recursiva(numbersArray);
}
}
Aquí un artículo que compara a profundidad los ciclos iterativos vs. los ciclos recursivos.
La recursion nos permite hacer un codigo más elegante, sacrificando la eficiencia (además de ofrecernos soluciones en casos muy particulares)
Ej:
function recursive(num) {
console.log(num);
num < 50 && recursive(num+1)
}
vs
function forLoop() {
for(let i = 1; i <= 50; i++) {
console.log(i)
}
}
Las diferencias pueden no ser muy claras con un script tan básico, pero cobra sentido cuando el ciclo se vuelve más complejo. Podemos usarlo si sabemos que un ciclo no va a tener muchas iteraciones (por ej, una llamada a 10 productos)
Podés encontrar ejercicios de recursividad en leetcode y codewars
Esto es lo que hice antes de ver el capitulo. :3
Un ejercicio de recursividad después de dos días de revisar el tema: 🤯
const contenNumbers = [0, 1, "Spiderman", 34, 4, 5, 777,"JuanDC", 6, 7, 8, "Batman", 435678, 900, 2, 3];
let eleWanted = "JuanDC";
const recurPosition = (arr, eleWanted, position) =>{
if (arr[position] == eleWanted) {
let element = arr[position];
return console.log({position, element})
} else {
recurPosition(arr, eleWanted, position - 1);
}
}
recurPosition(contenNumbers, eleWanted, contenNumbers.length - 1);
Hasta ahora no me gusta porque no entiendo para que me puede funcionar…
Me parece bastante importanten entender esta tecnica de programacion, yo con anterioridad en un proyecto que tuve utilice este metodo, pero no sabia su nombre hastra ahora, se trataba de sacar 2 valores aleatoriaos con la siguiente condicion: no tendria que ser el mismo valor que se muestra, osea, en este caso un post y que no se repitiera. utlizando la ayuda de objetos literales y la recursivad pude resolver el problrme 😛
Me encanto la recursividad, lo veo mucho más elegante ye entendible que el ciclo for
array de emojis con las comillas correctas
[
"✌",
"😂",
"😝",
"😁",
"😱",
"👉",
"🙌",
"🍻",
"🔥",
"🌈",
"☀",
"🎈",
"🌹",
"💄",
"🎀",
"⚽",
"🎾",
"🏁",
"😡",
"👿",
"🐻",
"🐶",
"🐬",
"🐟",
"🍀",
"👀",
"🚗",
"🍎",
"💝",
"💙",
"👌",
"❤",
"😍",
"😉",
"😓",
"😳",
"💪",
"💩",
"🍸",
"🔑",
"💖",
"🌟",
"🎉",
"🌺",
"🎶",
"👠",
"🏈",
"⚾",
"🏆",
"👽",
"💀",
"🐵",
"🐮",
"🐩",
"🐎",
"💣",
"👃",
"👂",
"🍓",
"💘",
"💜",
"👊",
"💋",
"😘",
"😜",
"😵",
"🙏",
"👋",
"🚽",
"💃",
"💎",
"🚀",
"🌙",
"🎁",
"⛄",
"🌊",
"⛵",
"🏀",
"🎱",
"💰",
"👶",
"👸",
"🐰",
"🐷",
"🐍",
"🐫",
"🔫",
"👄",
"🚲",
"🍉",
"💛",
"💚",
]
En cierta parte me gusta la recursividad en el sentido de que te ayuda a desarrollar ese pensamiento lógico.
Pero por otro lado en algunos casos es difícil de entenderla o implementarla.
Pero siempre es bueno saber como usarla ya que en un futuro es muy probable que la necesitemos
Por lo que sea que te guste la recursividad, se ve muy elegante. Además ayuda a comprender la lógica de programación.
LA RECURSIVIDAD es bastante peculiar porque suele funcionar autoejecutando funciones con un ámbito menos al problema padre.
Un caso recursivo: Suele ser una función que es capaz de autoinvocarse. La clave de esta autoinvocación es que los elementos que le pasemos tendrán que ser menores que los del problema padre ya que si no nunca podríamos llegar al caso base.
Así pues, La recursividad es cuando una función se llama a sí misma, haciendo que esta se ejecute infinitamente a no ser que tenga un límite.
Así pues, La recursividad
la verdad es que no entiendo la utilidad de la recursividad, mas parece como algo heredado de otro lado o que se utiliza en algunos casos mas específicos. La verdad tratare de darle utilidad por la parte que el código es relativamente mas corto. Sin embargo considero que es muy buen ejemplo pare reforzar los ciclos en JavaScript.
¿Escribir programas recursivos?
• Son más continuos a la representación matemática.
• son más fáciles de examinar
• Se acomodan mejor a las distribuciones de datos recursivas.
• Los algoritmos recursivos brindan recursos ordenadas.
• modulares y elegantemente simples.
¿Factible de utilizar recursividad?
• Simplifica el código.
• Estructura de datos es recursiva
¿No utilizar recursividad?
• Las técnicas usan arreglos largos.
• Método cambia de modo impredecible de campos.
• las iteraciones sean la mejor opción.
Lo hice asi,
`function recursive (numeros){
if (numeros.length != 0) {
// console.log(numeros.length)
const x = numeros.shift()
console.log(x)
recursive(numeros)
} else {
console.log("finish")
}
}
recursive(array)e>
El código podría resumirse a:
function recursiva(arrayNumeros) {
if( arrayNumeros.length != 0 ) {
// const firstNum = arrayNumeros[0];
// console.log(firstNum);
console.log(arrayNumeros.shift());
recursiva(arrayNumeros);
}
}
const obj1 = {
a: "a",
b: "b",
c: {
d: "d",
e: "e"
},
f: ["g", "h"],
editA(){
this.a = "AAA"
}
};
function recursiva(obj1){
const copiedObj = {}
for(const prop in obj1){
if(typeof prop == 'object'){
recursiva(obj1[prop])
} else{
copiedObj[prop] = obj1[prop]
}
}
return copiedObj
}
const obj2 = recursiva(obj1)
console.log(obj1)
console.log(obj2)
Les comparto mi versión de la recursión:
'use strict'
function cuentaRegresiva(num) {
console.log(num);
// Caso base
if (num === 0) {
return;
}
// Recursión
cuentaRegresiva(num - 1);
}
cuentaRegresiva(10);
Es un poco distinto en como escribí la función recursiva, pero creo que se entiende, además de que me funcionó, solo un poco distinto en la validación que se define:
function serie(list) {
let number = 0;
if(number < list.length) {
console.log(list[number])
list.shift();
return serie(list);
}
}
Una razón por la que me gusta la recursividad es porque puedes usarla para problemas que requieran dividir un problema más grande en problemas pequeños y así sucesivamente.
.
Sin embargo esto puede traer como consecuencia que aumente el uso de memoria, trayendo un aumento en la complejidad espacial (tamaño de memoria utilizado para resolver el problema), ya que cada llamado a la función recursiva implica más uso de memoria.
.
Hay ocasiones donde es útil, como cuando se quiere buscar por un sistema de archivos por ejemplo. Sin embargo hay otras situaciones donde no lo es tanto, ahí siendo mejor implementar un algoritmo iterativo como ciclos.
.
Fuente
La recursividad en mi opinión es MUY BUENA para MEJORAR nuestra lógica; sin embargo, en el día a día va a ser más rápido y sencillo usar ciclos for, while, do while. Dejando la recursividad para momentos donde sea 100% necesaria
La recursividad como dice el profesor podria muchas veces ahorrarnos muchas lineas de codigo, pero a mi entender debemos de tener cuidado al utilizarla y tambien tener muy claro donde y cuando la vamos a utilizar porque podria costarnos un monton en la aplicacion! puede generar un bucle infinito si no estamos claro de como se usa esta tecnica
Recursividad es una forma en la podemos trabajar para estar llamando metodo a si mismo, en lo que he investigue no es muy usado en el mundo laboral ya que puede generar un desborde de la memoria que rompa el programa que estamos realizando, asi que si deberia usarlo debe ser muy bien analizado y garantizando que no afecte el programa.
Comparto un ejercicio que hice:
/**
* Function itera sobre un número dado con una función recursiva
* @param {number} limit - limite del ciclo, para la condicional
* @param {function} cb - Un callback donde podemos poner la lógica basado en el limite del clico
* nos returna, count (index) - position del ciclo
*/
function customLoop(limit, cb) {
let count = 0
/**
* Función recursiva - itera con base en el limite - usando un count
* @param {number} limit
* @returns Misma funciónFunción recursiva
*/
function sum(limit) {
if (count < limit) {
cb(count)
count++
return sum(limit)
}
}
sum(limit)
}
const names = ['Daniel', 'Fernanda', 'Geraldine']
const namesCopy = []
//Pasamos un array a otro
customLoop(names.length - 1, (count) => {
namesCopy.push(names.shift())
})
Recursividad:
No se trata de si me gusta o no, se trata de sus casos de aplicación, una funcion recursiva lo que hace es crear un nuevo Scope, en otras palabras crea un pequeño mundo nuevo, asi que si lo que creo que va a pasar en la siguiente clase es que vamos a usar recursividad para poder copiar un objeto con sus propiedades, atributos, acciones en un nuevo Scope, utilizando la recursividad…
me gusta la recursividad porq nos permite romper los ciclos cuando lo necesitemos
Acá dejo un ejemplo claro de función recursiva:
//Series Fibonacci
let num_1 = 1;
let num_2 = 2;
let num_i = num_1 + num_2;
const series_fibonacci = (num) =>{
console.log(num_1, num_2, num_i);
if(num_i < num){
num_1 = num_2;
num_2 = num_i;
num_i = num_1 + num_2;
return series_figonacci(num);
}
}
Porque se ve muy maquiavélico
Sabías que el método de los Arrays shift() permite guardar el elemento extraído en una variable simultaneamente
let primerNumero = numbersArray.shift();
me gustará la recursividad cuando la domine por completo jaja
Recursividad es un caso para analizar, muchas veces necesitamos un programa iterativo o recursivo, no son iguales pero son muy utiles que existan
No me gusta la recursividad porque es dificil de implementar, consumen el stack de la memoria y porque no hay que inventarse la rueda. Creo que recursividad es buen para casos puntuales, pero es mejor evitarla.
Al trabajar con recursividad nuestro código es mas fácil de leer y nos ahorramos bastas líneas de código que un ciclo for , es mucho mas intuitivo(declarativo)
Bueno no estoy muy seguro, pero creo que mejoraría la seguridad ya que esta iteración esta encerrada dentro de una función?
Recursividad: Cuando una función se llama así misma y crea una ejecución de la función misma, llamándose a sí misma varias veces.
Un disparador || Una validación es lo que nos permite finalizar una función recursiva: devolvemos un valor y terminamos.
const numerito = ["1",2,"3",4,[5, 6], 7]
const recursive = (num: any) => {
if(num.length !== 0) {
const firstNum = num[0];
console.log(`firstNum`, firstNum)
num.shift();
recursive(num);
}
}
recursive(numerito)
function recursive(array) {
if (array.length !== 0) {
const first = array.shift();
console.log(first);
return recursive(array);
}
console.log('Finish');
}
recursive(numbers);
Implemente la recursividad de otra forma la comparto por si alguien le parece útil.
function recursiva(array, index = 0) {
if (index < array.length) {
console.log(array[index])
let index2 = index + 1;
recursiva(array, index2)
}
}
Hola! como estan?
Para practicar intente hacer una funcion recursiva que funcione como un bucle for!
let array = [1,23,41,52,42,5,656,6,98]
let numeroArray = 0;
let fun = (numerito) => {
if( numerito < array.length ) {
let valorArray = array[numerito];
console.log(valorArray);
return fun(numerito + 1)
} else {
console.log("fin");
}
}
let y = fun(numeroArray);
Aqui les dejo un ejemplo que indague con recursividad
function factorial(n) {
// Caso base: si n es 0, el factorial es 1
if (n === 0) {
return 1;
}
// Caso recursivo: calcular el factorial de n-1 y multiplicarlo por n
else {
return n * factorial(n - 1);
}
}
// Calcular el factorial de 5
console.log(factorial(5)); // Resultado: 120
Creo que la próxima clase, sera de oro. Porque por fin podremos apreciar un ejemplo con recursividad más práctico por así decirlo. No me gusta la recursividad porque la legibilidad y el no saber en donde aplicarlo o no, ya que sin recursividad podemos obtener el mismo resultado, solo por esa razón.
La recursividad es cuando una función se llama a sí misma y esta genera una nueva ejecución de la función. Esto sucede reiteradamente hasta que cumpla o no con cierta validación que nosotros declaremos para que deje de llamarse a sí misma en algún punto
Este es otro ejemplo que puede funcionar
function recursivo (EditArray){
if (EditArray.length > 0){
console.log(EditArray[0]);
recursivo(EditArray.slice(1));
}
}
espero les sirva
Apuntes de la clase
Qué es la recursividad
https://www.notion.so/mriatorres/Recursividad-08488dfb1b994de4aef4e7a6cca7c4e7
function recursiva() {
if(/* validación */) {
// llamados recursivos
} else {
// llamados normales, sin recursividad
}
}
function recursiva() { if(/* validación */) { // llamados recursivos } else { // llamados normales, sin recursividad } }
Una aplicación de la recursividad es la copia de objetos con métodos
Mi resumen:
/*------------------Recursividad------------------*/
//Es cuando una función se llama a sí misma y crea una nueva ejecución de esa función.
//Estas ejecuciones pueden ser sucesivas hasta llegar a un punto donde se obtenga un valor en espcífico.
//A partir de ahí se ira resolviendo cada una de las ejecuciones hechas
//Donde haya un ciclo iterativo (while, for, etc), se puede aplicar recursividad en vez de ese ciclo y la elección dependerá del contexto.
//### PROBLEMA: Deseamos imprimir una serie de números desde el 0 hasta n números. En este caso hasta el 4
let numerito = 0;
//Solución con ciclos iterativos
while(numerito < 5) {
console.log(numerito);
numerito++;
}
// Solución con función recursiva
function recursiva(numerito) { // Recibe un número
console.log(numerito); // Imprimimos en consola el número
if (numerito < 5) { // Evalua si es menor a 5
// Llamamos nuevamente a nuestra función enviandole el número siguiente:
return recursiva(numerito + 1);
} else { // La función deja de llamarse a sí misma:
return 5;
}
}
recursiva(numerito);
/*
Output:
0
1
2
3
4
5 //este es por el return al parar las ejecuciones secuenciales
*/
// ### ¿Cuándo SÍ es factible de utilizar recursividad?
/*
-Para simplificar el código.
-Cuando la estructura de datos es recursiva. Ejemplo: árboles.
*/
// ### ¿Cuándo NO es factible utilizar recursividad?
/*
-Cuando los métodos usen arreglos largos.
-Cuando el método cambia de manera impredecible de campos.
-Cuando las iteraciones sean la mejor opción
*/
no se si a otros les pasa o solo yo, pero ojo con confundir “length” con"lenght", visual studio no lo marca como error pero en este caso tipiandolo asi te da una recursividad infinita y nunca termina 😄
RECORDATORIO: porque presiento que habemos una clasificación de personas que repetiremos este error por siempre esto por siempre.
Se escribe length… jajaja 😅
el tema de la recursividad es tener ese farol cuando se cumpla y en este momento romper la recursividad pero que tan rapida es sobre otras maneras como for.
function numerito(numero, mayor){
console.log(`numero actual : ${numero} = ${mayor}`);
if(numero < mayor){
numero++;
numerito(numero,mayor);
}else{
console.log(`finalizacion del contador ${numero}`)
}
}
numerito(1,10)
la recursividad es algo que se deberia enseñar al comienzo de los cursos de programación ya que entiendes mas el porque se hace un ciclo y como no fallar en el intento explotanto el motor V8 o congelando tu computadora corriendo el codigo desde vscode JAJAJ.
Yo creo que una función recursiva o Loops son muy importantes solo que uno tiene menos códigos que el otro pero ambos son importantes.
Pero en que momento deberíamos usar la recursividad?
No lo sé, creo que hace falta un caso de la vida real para que quede más claro, así que de una voy a la próxima clase. 😃
Pues teniendo en cuenta “problema de copiar un objeto” aun no tenemos el metodo ultimateExtraYaNoMasPlussUltraForCopyObjects .
creo que vamos a terminar usando la recursividad para ir evaluando cada propiedad del objeto y copiarla segun convenga.
tantas veces como props tenga el objetoOrigina.
Ya estaba a punto de decir:
¿Y esto qué tiene que ver con POO?
Pregunten a los Devs senior cuantas veces usan recursividad en su trabajo.
En mi opinión personal se me hace mas fácil trabajar con recursividad que con ciclos, aunque he estado leyendo que la recursividad no es tan buena ya que ocupa mucho espacio en memoria y eso hace que sea poco escalable.
ok
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?