Factory pattern y RORO

Al escuchar RORO fue lo primero que se me vino a la cabeza. xD

Comparto el código usando TS 💙

En Typescript podemos declarar interfaces (es algo así como un contrato para crear un objeto), y declarar propiedades que sean opcionales con el signo de interrogación ‘?’, las demás serán obligatorias, en caso de no cumplir con el contrato, el lenguaje te avisara antes de ejecutar el código. 😀

.

Factory pattern y RORO

Lectura muy mucho importante!

Elegant patterns in modern JavaScript: RORO

Código Clase

/* Codigo Deep Copy */

// Requerimientos de parametros obligatorios
function requiredParam(param){
    throw new Error(param + " Campo obligatorio");
}

// Fabrica de estudiantes
function createStudent({
    name = requiredParam("name"),
    email = requiredParam("email"),
    age,
    twitter,
    instagram,
    facebook,
    approvedCourses = [],
    learningPaths = [],
} = {}) {
    return {
        name,
        age,
        email,
        approvedCourses,
        learningPaths,
        socialMedia: {
            twitter,
            instagram,
            facebook,
        },
    };
}

const carlos = createStudent({
    name: 'Carlito',
    age: 20,
    email: '[email protected]',
    twitter: 'carlitosmzz',
}); // {}

RORO PIRRORO

**RORO **= Recibir un Objecto, y Retornamos otro Objecto.

Dentro de una función, recibimos un solo parámetro que es un objecto, el cual internamente contiene varias propiedades, con las cuales retornara otro nuevo objeto.

Este curso, de lejos, se queda como de los mejores, Juan es todo un crack, tanto enseñando como sabiendo que enseñar 😮

Puedes también crear una fabrica de instancias de prototipos con esta función ejemplo:

function createNewCourse({name,school,score,lang,freeAcces}){

    return new Courses({

        name,
        school,
        score,
        lang,
        freeAcces
    })
}

7 FACTORY PATTERN Y RORO

RORO es un patrón de diseño que consiste en crear una función que devuelve un objeto.
RO -> Recibir un objeto
RO -> Retornar un objeto

function requiredParam(param){
    throw new Error(param + "missing parameter")
}

el código anterior es una función que retorna un error.

function createStudent({
    name = requiredParam("name")
    email = requiredParam("email"),
    age,
    aprrovedCourses = [],
    learningPaths = [],
    socialMedia,
} = {})

tira error cuando no estamos eenviando ninguna propiedad name o email.

Like si te gustan los frijoles tanto como a juan!! 😂😆

Espectacular revisar lo de RORO añadiendo los parámetros por defecto.

Factory pattern y RORO

function requiredParam(param) {
  throw new Error(`Missing required parameter: ${param}`);
}

function createStudent({
  name = requiredParam('name'), //Mostará error si está vacío
  email = requiredParam('email'),
  age,
  twitter,
  facebook,
  instagram,
  approvedCourses = [], //valor por defecto
  learningPaths = [], //valor por defecto
} = {} /*Por defecto es un objeto vacío*/ ) {
  return {
    name,
    email,
    age,
    approvedCourses,
    learningPaths,
    socialMedia: {
      twitter,
      facebook,
      instagram
    },
  };
}

const juan = createStudent({
  name: 'Juan',
  email: '[email protected]',
  age: 20,
  twitter: '@fjuandc',
})

Recibir un objeto, retornar un objeto, anotado

Lo que está haciendo el profe en la función createStudent, se llama destructuring, que en términos generales lo que hace es una especie de desempaquetado de las propiedades de objetos o arrays:

entonces en vez de él hacer esto:

function createStudent(estudent) {
	return {
		name: student.name,
		age: student.age
		...
	}
}

lo que hace es un destructuring ese objeto student:

function createStudent({name, age, ... }) {
	return {
		name,
		age
		...
	}
}

Un enlace si quieren profundizar más:

Destructuring assignment

RORO = Recibir un Objecto, y Retornar otro Objecto.
Nos ayudan a crear moldes de objeto, pero no a partir de objetos literales, sino con funciones:

function requiredParams(param) {
  throw new Error(param + ": es un parámetro requerido")
};

function createStudent({
  name = requiredParams("name"),
  age = requiredParams("age"),
  email,
  twitter,
  instagram,
  github,
  approvedCourses = [],
  learningPaths =[],
} = {}) {
  return {
    name,
    email,
    age,
    socialMedia: {
      twitter,
      instagram,
      github
    },
    approvedCourses,
    learningPaths,
  }
};

const felipe = createStudent({
  name: "Felipe",
  email: "[email protected]",
  age: 28,
  github: 'afelipelds',
});

Creemos una función que creará objetos:

-Recibe como parametro un objeto para que no importe el orden en que se envían las propiedades

-Igualamos el parametro a un objeto vacío para que no exista error en caso de que no enviemos argumentos al llamar la función.

function createStudent({
  name, 
  email, 
  age,
  twitter,
  instagram,
  facebook,
  approvedCourses = [],
  learningPaths = [],
} = {})

-Retornamos un objeto con todas las propiedades enviadas (las propiedades no enviadas seran undefined)

{
  return {
    name,
    email,
    age,
    approvedCourses,
    learningPaths,
    socialMedia: {
      twitter,
      instagram,
      facebook,
    },
  };
}

-Pero si vamos a necesitar propiedades obligatorias, por esto, cuando no se envien vamos a lanzar un error

function requiredParam(param) {
  throw new Error(param + " es obligatorio");
}
function createStudent({
  name = requiredParam("name"),
  email = requiredParam("email"),
}={})

RORO patter

Es un patrón de código en el que se envía como parámetro a una función un objeto para devolver otro objeto, y el beneficio de esto principalmente es:

1. Enviar parámetros de forma más descriptiva
2. Ignorar el orden en el que deben ser colocados los parámetros

Me gustan mas las explicaciones del profesor Nicolas, mucho mas claro al usar objetos mas “reales”, es decir

Edificio{
	apartamento101{
		tipoApto{
			apto: suite
		},
		familiaRamirez{
			ana{
				genero: femenino,
				nombreCompleto: Ana Ramirez,
				edad: 30
			},
			sergio{
				genero: masculino,
				nombreCompleto: Sergio Ramirez,
				edad: 32
			},
		}
	},
	apartamento201{
		...
	}

en vez de

{a:b, {juanito: juan no esjuan}

se pueden escuchar carros de formula 1 en el minuto 10:38