No tienes acceso a esta clase

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

Nuevo Curso Práctico de JavaScript

Nuevo Curso Práctico de JavaScript

Juan David Castro Gallego

Juan David Castro Gallego

Bonus: reducción de condicionales

8/26
Recursos

Aportes 39

Preguntas 3

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Javascript se me ha dificultado muchote, pero confio en que con la practica y mi esfuerzo tendré buenos resultados. Me encanta aprender en Platzi!

si ya eres una experta o experto en el lenguaje, te desafío a comentar cómo replicar este comportamiento con **arrays ** y un solo condicional.

Nivel piedra:

// ---  Bonus ---
var arrayDeSuscripcion =[
  "Free" ,"Solo puedes tomar los cursos gratis",
  "Basic" ,"Puedes tomar casi todos los cursos de Platzi durante un mes",
  "Expert" ,"Puedes tomar casi todos los cursos de Platzi durante un año",
  "ExpertPlus","Tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año",
]
let pos = arrayDeSuscripcion.indexOf('Free');

if (pos != -1){
  console.log(arrayDeSuscripcion[pos+1])
}else{
  console.log('El plan no existe')
}

Espectacular , el curso anterior de Curso Practico de Js me causo mucha insertidumbre porque no podia lograr entenderlo, lo vi muchas veces y no logre entender a Juan, Este curso es totalmente distinto, excelente la forma de explicar , paso a paso muchas gracias por el nuevo curso!!

3️.Replica el comportamiento de tu condicional anterior con if, else y else if, pero ahora solo con if (sin else ni else if).

💡 Bonus: si ya eres una experta o experto en el lenguaje, te desafío a comentar cómo replicar este comportamiento con arrays y un solo condicional. 😏

let typeSuscripción = [
"Free",
"Basic", 
"Expert", 
"ExpertDuo"
];
let infoSuscripción = [
"solo puedes tomar los cursos gratis", 
"puedes tomar casi todos los cursos de Platzi durante un mes", 
"puedes tomar casi todos los cursos de Platzi durante un año", 
"tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año"];
let userSuscription = "ExpertDuo";
for (let i=0; i < typeSuscripción.length; i++) {
  if (userSuscription == typeSuscripción[i]) {
  	console.log(`Si estas suscrito al plan ${typeSuscripción[i]} en el cual ${infoSuscripción[i]}`)
  }
}
Whaaat, me pareció excelente la forma como se realizó el bonus, yo utilicé un ciclo y un condicional, no sabía que se podía verificar que una suscripción existiera de una forma tan fácil como se hizo. La verdad que muy bien. Me emociona lo mucho que aún me falta por aprender 💪

😃 Bonus: Reducción de condicionales

const tipoDeSuscripcion = 'Basic';
const suscripcion = ['Free','Basic','Expert','ExpertPlus'];
const descripcion = ['Solo puedes tomar los cursos gratis',
'Puedes tomar casi todos los cursos de Platzi durante un mes',
'Puedes tomar casi todos los cursos de Platzi durante un año',
'Tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año'];
if(true)
	console.log(descripcion[suscripcion.indexOf(tipoDeSuscripcion)]);

Qué buena forma de simplificar un condicional. Ahora la usaré a cada rato 😄

Me gustó bastante la solución del profe para el Bonus, limpio y directo. Como no sé me ocurrió ese hack de llamarlo con el key había usado el find del curso básico, aquí mi implementación para el que lo quiera comprar, igual me quedo con el del profe como favorito.

const tipoDeSuscripcion = "ExpertPlus";
const tipoDeSuscripciones = [
    {
        nombre : "Free",
        descripcion : "Solo puedes tomar los cursos gratis"  
    },
    {
        nombre : "Basic",
        descripcion : "Puedes tomar casi todos los cursos de Platzi durante un mes"  
    },
    {
        nombre : "Expert",
        descripcion : "Puedes tomar casi todos los cursos de Platzi durante un año"  
    },
    {
        nombre : "ExpertPlus",
        descripcion : "Tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año"  
    },

];

if (tipoDeSuscripciones.length > 0)
{
    var mitipo = tipoDeSuscripciones.find(function(mySuscripcion){
        return mySuscripcion.nombre  === tipoDeSuscripcion
    });
    console.log(mitipo.descripcion);
}

Lo intenté hace desde que fue el test, tardé horas y me gustaría decir que fue sola, pero si me ayudaron… de haberme esperado creo que si llegaba al mismo resultado.
Nuevos aprendizajes: Seguir aprendiendo antes de ir a solucionar un problema sin saber cómo y… La ayuda nunca está de más :3

 const suscripcionContratada = 'ExpertDuo'
 const suscripciones = [];

 suscripciones.push(
   {
      nom: 'Basic',
      value: "Sólo puedes tomar los cursos gratis o las primer clase de un curso",
   }
 );
 suscripciones.push(
   {
      nom: 'Expert',
      value: "SPuedes tomar todos los cursos de Platzi por un año",
   }
 ); suscripciones.push(
   {
      nom: 'ExpertDuo',
      value: "Puedes tomar todos los cursos de Platzi por un año junto con algiuen más.",
   }
 );


 suscripciones.map(
  function(suscripcion){
    if (suscripcion.nom == suscripcionContratada){
      console.log(suscripcion.value); 
   }    
  }   
)

Lo más importante de toda la clase.

const planes = ['expert', 'basic', 'free'];
function verificarPlan (suscripcion){
    if (planes.includes(suscripcion)){
        console.log('Plan valido');
        return;
    }
    console.log('Plan invalido');
}

3️⃣ Replica el comportamiento de tu condicional anterior con if, else y else if, pero ahora solo con if (sin else ni else if).
💡 Bonus: si ya eres una experta o experto en el lenguaje, te desafío a comentar cómo replicar este comportamiento con arrays u objetos y un solo condicional. 😏

let  suscriptions = [ 
	{	
		type:"Free",
		message: "solo puedes tomar los cursos gratis"
	},
	{	
		type:"Basic",
		message: "puedes tomar casi todos los cursos de Platzi durante un mes"
	},
	{	
		type:"Expert",
		message: "puedes tomar casi todos los cursos de Platzi durante un año"
	},
	{	
		type:"ExpertPlus",
		message: "tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año"
	}
];

const mySub = "Basic";

const findSub = suscriptions.find( sub => sub.type === mySub );
const result = findSub !== undefined? findSub.message: "Necesitas una suscripción válida";
console.log(result);

suscripciones = {
free: “freee”,
expert:“expertt”
}
var dato = “free” //este dato cambia por consola o como quieras
if(suscripciones[dato]){
console.log(suscripciones[dato])
}else console.log(“No existe”)

const tipoDeSuscripciones = {
    free: "Solo puede tomar los cursos gratis",
    basic: "Puedes tomar casi todos los cursos por un mes",
    expert: "Puedes tomar casi todos los cursos por un año",
    expertduo: "Puedes tomat todos los cursos durante un año",
}

function validarTipoSuscripcion (suscripcion) {
    if (tipoDeSuscripciones[suscripcion]) {
        console.log(tipoDeSuscripciones[suscripcion]);
        return; //Para finalizar validacion
    }

    console.warn("Este tipo de suscripcion no existe");
}

Para poder entender más de JavaScript, hay que practicarlo mucho. Hacer ejercicios o retos que al solucionar hayas logrado entender un poco más cómo funciona el lenguaje y tal vez encontrar alguna forma de optimizar el código. Yo lo que hago por lo general es solucionar algún tipo de problema cercano que pueda ser resuelto mediante código.

Ejemplo, un tic tac toe digital, un Sudoku digital, qué tal hacer el cálculo del promedio entre las notas de una clase pero que pida al usuario cada nota y su porcentaje…

Después de haber resuelto algún reto, habrás investigado y habrás comprendido algo más del lenguaje o quizás aprendido algo nuevo. 👌

Siento que se me facilita más esto que css

function main () {
  const answers = [
    {suscription: "Free", message:"Solo puedes tomar los cursos gratis"},
    {suscription: "Basic", message:"Puedes tomar casi todos los cursos de Platzi durante un mes"},
    {suscription: "Expert", message:"Puedes tomar casi todos los cursos de Platzi durante un año"},
    {suscription: "Expert plus", message:"Tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año"}
 ];

  const suscriptionSelect = Number((prompt("elige \n0 = Free \n1 = Basic \n2 = Expert \n3 = Expert Plus")));
    if(suscriptionSelect >= 0 && suscriptionSelect <= 3) {
      alert("elesgiste " + answers[suscriptionSelect].suscription);}
    else {
      alert("esta suscripción no existe");
      }
    }

      main ();
const planes = ['Basic', 'Expert', 'Expert+']

function saberPlan(plan){
  
  let msg = prompt("Que plan tienes?")
  if(msg == plan[0] || msg == plan[1] || msg == plan[2]){
    console.log("Tu plan es: " + msg)
  }else{
    console.log("Tu plan no está registrado en la data")
  }
}

saberPlan(planes)

Por acá les comparto mi solución 😄 ❤️

const tiposDeSuscripciones = [
  { suscripcion: "Free", 
		descripcion: "Solo puedes tomar los cursos gratis" },
  {
    suscripcion: "Basic",
    descripcion: "Puedes tomar casi todos los cursos de Platzi durante un mes",
  },
  {
    suscripcion: "Expert",
    descripcion: "Puedes tomar casi todos los cursos de Platzi durante un año",
  },
  {
    suscripcion: "ExpertPlus",
    descripcion:
      "Tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año",
  },
];

function suscription(tipoDeSuscripcion) {
  let encuentraSuscripcion = tiposDeSuscripciones.find(function (suscripcion) {
    return suscripcion.suscripcion === tipoDeSuscripcion;
  });
  console.log(encuentraSuscripcion.descripcion);
}

suscription("Free");

Yo lo hice de la siguiente forma

const mySuscription2 = 'ExpertPlus';
const suscrip = {
	Free: 'solo puedes tomar los cursos gratis',
	Basic: 'puedes tomar casi todos los cursos de Platzi durante un mes',
	Expert: 'puedes tomar casi todos los cursos de Platzi durante un año',
	ExpertPlus:
		'tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año',
};

for (let i = 0; i < Object.keys(suscrip).length; i++) {
	if (Object.keys(suscrip)[i] == mySuscription2) {
		console.log(Object.values(suscrip)[i]);
	}
}

Using an object to solve a searching with if problem.sq

con objetos se pueden hacer validaciones sin utilizar condicionales. ejemplo:



    const conseguirTipoDeSuscripcion = suscription=>{
        const listaPlanes= {
            Free: 'solo puedes tomar los cursos gratis',
            Expert: 'puedes tomar casi todos los cursos de platzi durante un año',
            Basic: 'Puedes tomar casi todos los cursos de platzi durante un mes',
            ExperDuo: 'Tu y alguien mas pueden tomar TODOS los cursos de platzi durante un año'
        }
        return listaPlanes[suscription] || 'lo siento ese tipo de suscripcion no existe';
    };
    console.log(conseguirTipoDeSuscripcion('Expert'));
// puedes tomar casi todos los cursos de platzi durante un año

Yo lo había hecho así 😄

let elegida = "Experts";

var Suscription = [
    { tipo: "Free", info: "solo puedes tomar los cursos gratis" },
    { tipo: "Basic", info: "puedes tomar casi todos los cursos de Platzi durante un mes" },
    { tipo: "Experts", info: "puedes tomar casi todos los cursos de Platzi durante un año" },
    { tipo: "Expert Plus", info: "tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año" }
]

//CONDICIONAL CON OBJETO
for (let i = 0; i < Suscription.length; i++) {

    if (Suscription[i].tipo == elegida) {
        console.log(Suscription[i])
    }
}

Mis apuntes
VARIABLES
Si estabamos en variables ¿por qué decidi crear una función? El profesor Juan Da creo dos variables que resolvieron el test y fue más sencillo así.

FUNCIONES
La cereza del pastel. Creo que acabo de comprender como se usan los parametros de las funciones y cuales son los argumentos. Además me acaban de dejar claro que una función es un bloque de código y retornan una ejecución.
Una función puede guardar una variable y que a la vez esta variable guarde una función.
El punto y coma es una buena practica para terminar cada línea de código.

CONDICIONALES
Las condicionales If y Switch se diferencian en su estructura. La condicional If usa else if y else, la condicional Switch usa case, break y default.

CICLOS
Parece que los ciclos For y While son los más comunes. También las condicionales son otra forma de ciclos…
Estos ciclos o bucles trabajan mucho con operadores y repiten procesos hasta que falla o termina la condición y entonces se detiene.

ARRAY
Un array es una lista de elementos.
La coma separa los elementos en nuestro array. El dato curioso es que la coma también concatena e incluso hace que los elementos se vean más bonitos, pero en este caso la coma solo separa los elementos y le deja la concatenación al plus. Fuera de los arrays la coma me gusta más para concatenar porque además separa con un espacio la cadena de strings.

OBJETOS
Guardan cosas con nombres. Esto hace al array también un objeto porque un array puede tener un nombre al igual que los objetos.
Los objetos se pueden tranformar en arrays con el método .value() así de la siguiente manera array.value(nombreDelObjeto)
Para inicializar una variables dentro de un objeto lo hacemos con dos puntos (😃 y su valor lo digitamos dentro de comillas ("…")

BONUS
Dentro del ejercicio hemos creado una condicional If. Luego esta la convertimos en una función en vez de usar la condicional Switch y después de esto creamos un objeto para ejecutar la función con notación de punto y de corchete.

Excelente la particularidad de los objetos para ahorrar espacio. Esta brutal este curso muchas gracias.

El último bonus lo resolví de esta manera:

const subscriptions = [
  {
    type: "Free",
    message: "Solo puedes tomar los cursos gratis",
  },
  {
    type: "Basic",
    message: "Puedes tomar casi todos los cursos de Platzi durante un mes",
  },
  {
    type: "Expert",
    message: "Puedes tomar casi todos los cursos de Platzi durante un año",
  },
  {
    type: "ExpertPlus",
    message:
      "Tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año",
  },
];

function getSubscriptionMessage(type) {
  const subscription = subscriptions.find(
    (subscription) => subscription.type === type
  );
  if (subscription) {
    console.log(subscription.message);
  } else {
    console.warn("No cuentas con una suscripción :c");
  }
}

getSubscriptionMessage("ExperPlus");

function beneficiosDeSuscripcion(suscripcionAEvaluar){
	//Por defecto se asume que la suscripción no hace match con ninguna
	let resultado = "No se encuentra la suscripción en el sistema";
	let suscripciones = [
		{suscripcion: "Free", mensaje: "Solo puedes tomar los cursos gratis"},
		{suscripcion: "Basic", mensaje: "Puedes tomar casi todos los cursos de Platzi durante un mes"},
		{suscripcion: "Expert", mensaje: "Puedes tomar casi todos los cursos de Platzi durante un año"},
		{suscripcion: "ExpertPlus", mensaje: "Tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año"}
	];

	//Se compara convertido a mayúsculas
	suscripciones.forEach(suscripcion => {
		if(suscripcion.suscripcion.toUpperCase() === suscripcionAEvaluar.toUpperCase()){
			//Si coincide la suscripción a evaluar con alguna almacenada el resultado se sobreescribe con el mensaje correspondiente
			resultado = suscripcion.mensaje;
		}
	});
	return resultado;
}

Se nota la experiencia, yo le hice una solución con prácticamente los mismos elementos, pero incluso yo que lo veo ahora me parece super arcaico, sobre todo porque (no es la primera vez que me pasa) pero olvido que puedo usar el nombre o identificador de una variable y reemplazarlo con un concepto que ya tengo, en este caso los tipos de suscripciones jajaja dejo mi versión anterior para contrastar.


const tipoDeSuscripcion = "Basic";
var planes = [{tipo: "Free", leyenda: "Solo puedes tomar los cursos gratis"},
              {tipo: "Basic", leyenda: "Puedes tomar casi todos los cursos de Platzi durante un mes"},
              {tipo: "Expert", leyenda: "Puedes tomar casi todos los cursos de Platzi durante un año"},
              {tipo: "ExpertPlus", leyenda: "Tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año"}];
function validacion(tipo, planes){
    for(var plan of planes){
        if(tipo === plan.tipo){
            console.log(plan.leyenda);
        }
    }
}

Super chevere!

De esta manera resolví el desafío

const suscriptions = {
    Free : "Solo  puedes  tomar los cursos gratis",
    Basic : "Puedes tomar los cursos durante  un mes",
    Expert : "Puedes tomar casi todo los cursos durante un año",
    ExpertDuo : 'Tu  y alguine mas pueden tomar todos los cursos de platzi por un año'

}

function valSuscription(objeto, tipo){
    for(const elemento in objeto){
        if(elemento == tipo){
            console.log(`Con ${elemento} ${objeto[elemento]}`);
        }
    }
}

valSuscription(suscriptions,'Basic');

Mi aporte utilizando un arreglo que guarde objetos y después iterando a través de un for

function subscription(type, bennefits){
    this.type = type;
    this.bennefits = bennefits;
}

let subscription1 = new subscription("Free","Solo puedes tomar los cursos gratis");
let subscription2 = new subscription("Basic","Puedes tomar casi todos los cursos de Platzi durante un mes");
let subscription3 = new subscription("Expert","Puedes tomar todos los cursos de Platzi durante un año");
let subscription4 = new subscription("ExpertPlus","Tú y alguien más pueden tomar TODOS los cursos de PLATZI durante un año");

let subscriptions = [subscription1, subscription2, subscription3, subscription4];

let selection = "Basic";

for (let subscription of subscriptions){
    if (subscription.type == selection){
        console.log(subscription.bennefits);
    }
}

Yo realicé ese bonus de esta forma mientras realizaba el test:

let memberships = [
        {name: 'free', message: 'Solo puedes tomar los cursos gratis'},
        {name: 'basic', message: 'Puedes tomar casi todos los cursos de Platzi durante un mes'},
        {name: 'expert', message: 'Puedes tomar casi todos los cursos de Platzi durante un año'},
        {name: 'expertplus', message: 'Tú y alguien más pueden tomar TODOS los cursos de Platzi dureante un año'}
    ];

    function memberBenefit(word) {

        word = word.trim().toLowerCase();
        for (let i = 0; i < memberships.length; i++) {
            if (memberships[i].name === word) {
                return (`${memberships[i].name}: ${memberships[i].message}`);
            }
        }
        console.warn('Esa sucripción no existe, lo siento.')
    }

    console.log(memberBenefit('lkdfjldskf'));
    console.log(memberBenefit('ExpERtpLuS'));
	

Basicamente es crear un objeto y posteriormente llamar ese objeto en el if

let course = ['Free ', 'Basic', 'Expert', 'Expert Duo'];

function typeSus(course){
	if(course[0]){
		console.log(course[3]);
		return;
	}
	console.warn('Error!!');
}
typeSus(course[0])

siento que vere esta clase una y otra vez

Creo que me lo complique un poco, pero fue la primera solución que se me vino a la mente y funcionó…

let suscripcion = 'Free'
function arrOnly(suscription) {
    let keyMessage = ['Free', 'Basic', 'Expert','Duo']
    let message = ['Eres Free', 'Eres Basic', 'Eres Expert','Eres Duo']
    for (let i=0; i < keyMessage.length; i++) {
        if ( suscripcion === keyMessage[i] ) {
            console.log(message[i])
        }
    }
}

Excellent solution JuanDC! 👏🏻

Lo más importante de toda la clase.