No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Curso Pr谩ctico de JavaScript

Curso Pr谩ctico de JavaScript

Juan David Castro Gallego

Juan David Castro Gallego

Bonus: reducci贸n de condicionales

8/29
Recursos

Aportes 197

Preguntas 13

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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!!

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 馃挭

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]}`)
  }
}

As铆 lo hice yo usando solo una funci贸n.

const tiposDeSuscripciones = {
    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'
 }

 function encontrarSuscripcion(suscripcion){
    return tiposDeSuscripciones[suscripcion];
 }

Mi soluci贸n 馃槃 !!

Qu茅 buena forma de simplificar un condicional. Ahora la usar茅 a cada rato 馃槃

Bonus脩 desafio con un solo condicional.

let respuesta = prompt("Ingresa el tipo de suscripcion que tienes");

const tipoSuscripciones = {
    free : 'Solo puedes tomar los cursos gratis',
    basic : 'Solo puedes tomar los cursos gratis',
    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'
}

function suscripcion (tipo) {
    if (tipoSuscripciones[tipo]){
        console.log(tipoSuscripciones[tipo]);
        return;
    }
    console.warn("Ese tipo de suscripcion no existe");
}

suscripcion(respuesta);

馃槂 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)]);

Dejo mi aporte con dos formas diferente de hacerlo: con arrays y con un objeto

Con Arrays

const tipoSuscripciones = ["Free", "Basic", "Expert", "ExpertPlus"];
const descripcionSuscripciones = ["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"];

function obtenerSuscripcion(suscripcion){
    const index = tipoSuscripciones.indexOf(suscripcion);
    if (index != -1) {
        console.log(descripcionSuscripciones[index])
    }
}

Con un Objeto

const tipoSuscripcionesObj = {
    "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",
    "ExpertDuo": "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"
}
function obtenerSuscripcion(suscripcion){
    console.log(tipoSuscripcionesObj[suscripcion])
    
}

Si usas la funcion para cualquier caso:

obtenerSuscripcion('Basic')

La respueta ser谩 鈥淧uedes tomar casi todos los cursos de Platzi durante un mes鈥

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); 
   }    
  }   
)

siento que vere esta clase una y otra vez

Asi me salio

const tiposDeSuscripciones = {
    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',
    expertduo: ' T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o',
};

function seleccionSuscripcion(suscripcion){
    let plan = tiposDeSuscripciones[suscripcion];
    return console.log(plan)
}

seleccionSuscripcion("free");

Lo m谩s importante de toda la clase.

Lo m谩s importante de toda la clase.

as铆 es la programaci贸n uno empieza desde cero uno se da cuenta que se le va dificultando, pero, practicando viendo cursos o tutoriales uno va entendiendo

Comparto mi solucion usando: arreglos de un bjeto

const tipoDeSuscripcion = "Basic";
var planPlatzi = []; 
var plan = {};

plan = {tipoDeSuscripcion: "Free", beneficio:"Solo puedes tomar los cursos gratis"};
planPlatzi.push(plan);
plan = {tipoDeSuscripcion: "Basic", beneficio:"Puedes tomar casi todos los cursos de Platzi durante un mes"};
planPlatzi.push(plan);
Plan = {tipoDeSuscripcion: "Expert", beneficio:"Puedes tomar casi todos los cursos de Platzi durante un a帽o"};
planPlatzi.push(plan);
plan = {tipoDeSuscripcion: "ExpertPlus", beneficio: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"};
planPlatzi.push(plan);

planPlatzi.forEach(beneficio);
function beneficio(plan){
 if (tipoDeSuscripcion == plan.tipoDeSuscripcion) {
  console.log(plan.beneficio);
 }  
}

Aqu铆 mi aporte

Yo lo hice de la siguiente manera ya que del ejemplo del profesor funciona cuando tenga solo el 鈥渘ombre鈥 y la 鈥渄escripci贸n鈥 de la suscripci贸n.

{
	free: 'Solo puedes tomar los cursos gratis',
	Basic: 'Puedes tomar casi todos los cursos de Platzi durante un mes'
}

Quiz谩s si quisi茅ramos que tenga mas valores como nombre, descripci贸n, estado, precio, etc. creo que tendr铆a que en lugar de la descripci贸n colocar un array para almacenar mas valores:

{
	free: ['Solo puedes tomar los cursos gratis','activo',0],
	Basic: ['Puedes tomar casi todos los cursos de Platzi durante un mes'','activo',600]
}

Por eso prefer铆 crear cada suscripci贸n como un elemento del objeto para poder manejar mas valores por cada suscripci贸n as铆:

var suscripciones = [
    {
        tipo:"Free",
        beneficio:"Solo puedes tomar los cursos gratis",
        precio:0
    },
    {
        tipo:"Basic",
        beneficio:"Puedes tomar casi todos los cursos de Platzi durante un mes",
        precio:600
    },
    {
        tipo:"Expert",
        beneficio:"Puedes tomar casi todos los cursos de Platzi durante un a帽o",
        precio:800
    },
    {
        tipo:"ExpertPlus",
        beneficio:"T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o",
        precio:1000
    }
];

var suscripcionDelUsuario = "Expert";

suscripciones.forEach(function(suscripcion){
    if(suscripcion.tipo===suscripcionDelUsuario){
        console.log("Estas suscrito al tipo: " + suscripcion.tipo + " y tu beneficio es:  "+suscripcion.beneficio + " y el precio es:  "+suscripcion.precio)
    }
})

No habia puesto atencion que los ejercicios eran sin HTML jeje creo que deje algunos spoilers entonces, pero a煤n asi buenisima esta parte, gracias Juan, me encant贸 el ejercicio bonus increible todo lo que puede hacerse con JavaScript para datos.

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);
}

debo decir que me mato esa ultima forma, de reducir el codigo, deberian dejar mas practicas como esas para volar la mente

Siento que se me facilita m谩s esto que css

function suscrip(x){
  let plan = prompt('escoge tu plan: ');
  for(let i in x){
    if (plan === i){
      console.log(x[i])
    }
   }
}
let objeto = {
  Free:'solo puedes ver los gratis',
  Expert:'un a帽o solo una persona',
  Duo:'un a帽o dos personas'};


suscrip(objeto);

Otras maneras de cumplir el reto del bonus:
Recorre objetos en JS

let suscription = {
    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 anio",
    ExpertDuo: "Tu y alguien mas pueden tomar todos los cursos de Platzi durante un anio"
    
}

function tipoSuscripcion(value){
    if (suscription[value]){
        console.log(`${value}: ${suscription[value]}`);
    } else {
        console.log(`El plan ${value} no existe`)
    }
}

tipoSuscripcion("Basic");

yo lo hice con esta funci贸n que estaba en una de las clases de fundamentos de JavaScript

let tipoDeSuscripcion = "Basic";
  
let suscripPlatzi = [
    {nombre: "Free" , mensaje: "Solo puedes tomar los cursos gratis"},
    {nombre: "Basic" , mensaje: "Puedes tomar casi todos los cursos de Platzi durante un mes"},
    {nombre: "Expert" , mensaje: "Puedes tomar casi todos los cursos de Platzi durante un a帽o"}, 
    {nombre: "ExpertPlus" , mensaje: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"
} ]

let suscrip = suscripPlatzi.find(function(type){
    return type.nombre === tipoDeSuscripcion;
});

console.log(suscrip.mensaje);
function getTipoSuscripcion(sus){ 
	console.log( tiposSuscripcion[sus]? tiposSuscripcion[sus] : "Este tipo de suscripcion no existe") 
}

Yo lo hice de esta forma.

const suscripcion = [
    {tipo: "Free", veneficio: "Solo puedes tomar los cursos gratis"},
    {tipo: "Basic", veneficio: "Puedes tomar casi todos los cursos de Platzi durante un mes"},
    {tipo: "Expert", veneficio: "Puedes tomar casi todos los cursos de Platzi durante un a帽o"},
    {tipo: "ExpertPlus", veneficio: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"}
];
function tipoDeSuscripcion(seleccionSuscripcion){
    seleccionSuscripcion = suscripcion.find(function(seleccion){
        if (seleccion.tipo === seleccionSuscripcion) {
            console.log(seleccion.veneficio)
        }
    })
}
tipoDeSuscripcion("Expert");

Holaa aca dejo mi solucion del bonus 馃槂

Crack de maestro馃弳
let sus = ['Free', 'Basic', 'Expert', 'ExpertDuo'];
let message = ['Solo puedes tomar los cursos gratis', 'Puedes tomar todos los cursos de Platzi gratis durante un mes', 'Puedes tomar casi todos los cursos de Platzi durante un a帽o', 'Puedes tomar los cursos de Platzi con alguien gratis durante un a帽o'];

function imprimir (suscription) {
    for(let i = 0; i < sus.length; i++) {
        if (sus[i] == suscription) {
            document.write(message[i]);
        }
    }
}

imprimir(prompt('驴Que tipo de suscripci贸n deseas?'));

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])
        }
    }
}

Esta fue mi forma de hacerlo solo con arrays:

const suscriptions = ["Free", "Basic", "Expert", "ExpertDuo"];
const responses = [
   "You only have access to free courses",
   "You have access to all courses exept Englis and Startups",
   "You have access to all courses",
   "You and one more person have access to all couses",
];

const suscriptionType = (suscription) => {
   for (st of suscriptions) {
      if (st == suscription) {
         console.log(responses[suscriptions.indexOf(st)]);
         return;
      }
   }
   console.warn("The suscription doesn't exist");
};

suscriptionType("Expert");

lo mejor es como se simplifica el problema yo en mi soluci贸n lo enrevese demasiado pero el ejemplo de Juan me gusto al parecer entre m谩s recursos conoces m谩s valor necesitas para no utilizarlo.

let suscription = [
    {
        type: "Free",
        desc: "You can access only the free courses"
    },
    {
        type: "Basic",
        desc: "You can access almost all the courses for a month"
    },
    {
        type: "Expert",
        desc: "You can access almost all the courses for a year"
    },
    {
        type: "ExpertDuo",
        desc: "You and a FRIEND can access ALL the courses for a year"
    }
];

const yourSucription = prompt("Which one is your suscription, Free, Basic, Expert or ExpertDuo (Write it with the correct capitals)");

function suscriptionDetermination () {
    let findSuscription = suscription.find(element => element.type == yourSucription)
    if(findSuscription) {
        console.log(findSuscription.desc)
        return
    }
    console.warn("Write a valid answer");
}

suscriptionDetermination(suscription);

Bonus sin usar ni un solo condicional 鈽狅笍

function tipoSuscripcion(suscripcion) {
    const SUSCRIPCIONES = {
        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",
        ExpertDuo: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"
    }
    let suscripcionElegida = SUSCRIPCIONES[suscripcion] || "Entrada inv谩lida";
    console.log(`${suscripcion} = ${suscripcionElegida}`);
};
const tipoDeSuscripcion = "Basic";

switch (tipoDeSuscripcion) {
    case "Free":
        console.log("Solo puedes tomar los cursos gratis");
        break;
    case "Basic":
        console.log("Puedes tomar casi todos los cursos de Platzi durante un mes");
        break;
    case "Expert":
        console.log("Puedes tomar casi todos los cursos de Platzi durante un a帽o");
        break;
    case "ExpertPlus":
        console.log("T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o");
        break;
    default:
        console.log("Tipo de suscripci贸n no reconocido");
}

Yo lo resolv铆 sin ning煤n if xd


const tipoDeSuscripcion = 'Basic';

const planesPlatzi = [
  { name: 'Free', accessTo: 'Solo puedes tomar los cursos gratis' },
  { name: 'Basic', accessTo: 'Puedes tomar casi todos los cursos de Platzi durante un mes' },
	{ name: 'Expert', accessTo: 'Puedes tomar casi todos los cursos de Platzi durante un a帽o' },
  { name: 'ExpertPlus', accessTo: 'T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o' },
]

let plan = planesPlatzi.filter(plan => plan.name === tipoDeSuscripcion)

console.log(plan[0].accessTo)

Me quedo admirada lo excelente que explica JuanDC鈥 Tiene la habilidad particular hacer sencillo lo complejo鈥 Lo importante es que explica desde 0 la raz贸n de la existencia de un elemento y luego te lo presenta en su utilidad total鈥 Todo un Expert鈥 Admiro su metodolog铆a.

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. 馃憣

es muy importante utilizar el else if:
let suscripcion = 鈥楤asic鈥;
validarSus(suscripcion);
function validarSus(suscripcion){
if( suscripcion == 鈥楤asic鈥 ){
console.log(鈥楾omas Cursos Gratis鈥);
}
else if(suscripcion == 鈥楳edium鈥){
console.log(鈥楾omas Cursos Durante 5 Meses鈥);
}
else if(suscripcion == 鈥楿nli鈥){
console.log(鈥楾omas todos los Cursos durante un anio鈥);
}
else{
console.log(鈥楲o siento Suscripcion Invalida鈥);
}
}

Asi lo hice yo

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

 var suscripcionesPlatzi = { 

  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", 

}; 

  
function suscripcion(tipoDeSuscripcion) { 

  if (tipoDeSuscripcion === "Free" || tipoDeSuscripcion === "Basic" || tipoDeSuscripcion === "Expert" || tipoDeSuscripcion === "ExpertPlus") { 

    console.log(suscripcionesPlatzi[tipoDeSuscripcion]); 

  } 

} 
//Prueba 1
suscripcion("Free"); 

const tiposDeSuscripciones = {
	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",
	expertduo: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o", 
};

function conseguirTipoSuscripcion(suscripcion) {
	if (tiposDeSuscripciones[suscripcion]) {
	console.log(tiposDeSuscripciones[suscripcion]);
	return;
	}
	console.warn("Tipo de suscripcion incorrecta");
}

conseguirTipoSuscripcion("expertduo");

Intent茅 hacerlo con clase y objetos

class typeSuscription {
    constructor(plan,beneficio){
        this.plan = plan;
        this.beneficio = beneficio;
    }
}

let tipoDeSuscripcion = "Free";

let free = new typeSuscription("Free","Solo puedes tomar los cursos gratis");
let basic = new typeSuscription("Basic","Puedes tomar casi todos los cursos de Platzi durante un mes");
let expert = new typeSuscription("Expert","Puedes tomar casi todos los cursos de Platzi durante un a帽o");
let expertPlus = new typeSuscription("ExpertPlus","T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o");

if (free.plan == tipoDeSuscripcion){
    console.log(free.beneficio);
}
let tiposDeSuscripcion = {
        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",
        ExpertDuo: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o",
    }

    let nivel = "Expert"

    function imprimeLaDescripcion (descripcion){
        if(descripcion[nivel]){
            console.log(descripcion[nivel]);
            return
        }
        
        console.warn("Este tipo de suscripcion no existe")
    }

    imprimeLaDescripcion (tiposDeSuscripcion);

let tipoDeSucripcion = [鈥淔ree鈥,鈥淏asic鈥,鈥淓xpert鈥,鈥淓xpertPlus鈥漖;

if (tipoDeSucripcion.indexOf(鈥淏asic鈥) == true) {
console.log(鈥淧uedes tomar casi todos los cursos de Platzi durante un mes鈥);
}

Aqui dejo mi forma de hacerlo.
Saludos.

function tipoSus(suscripcion){
    let tipoSuscripciones=Array('Free','Basic','Expert','ExpertDuo');
    let descripcionSuscripcion=Array('Solo puedes tomar los cursos gratis','Puedes tomar casi todos los cursos durante 1 mes','Puedes tomar casi todos los cursos durante 1 ao','Tu y alguien mas pueden tomar TODOS los cursos durante 1 ao');
    for(let i=0; i<tipoSuscripciones.length;i++){
        if(tipoSuscripciones[i]==suscripcion.value){
            console.log('Tu tipo de suscripcion es: ',tipoSuscripciones[i])
            console.log(descripcionSuscripcion[i]);
            return;
        }
    }
    console.warn("Suscripci贸n inv谩lida");
}

8/27 Bonus: reducci贸n de condicionales
Utilizar solamente ciclos if sin else if ni esle.

Se propone colocar todos los condicionales dentro de una funci贸n y utilizar el 鈥渞eturn鈥 para detener la ejecuci贸n en caso de cumplirse una condici贸n, y en caso contrario, seguir con los siguientes.

Se muestra c贸mo se logra replicar el comportamiento de un condicional con variass opciones utilizando solamente condicionales if.

Adem谩s, se explica c贸mo colocar una respuesta por defecto en caso de que el tipo de suscripci贸n no est茅 entre las opciones definidas en la funci贸n.

<//ejemplo con arrays y un solo condicional
let typeSuscripci贸n = [//tipo de suscripcion
    "Free",
    "Basic", 
    "Expert", 
   "ExpertPlus"
    ];

    let infoSuscripci贸n = [//informacion de la suscription
   "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 = "ExpertPlus";//suscricion de usuario
    
   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]}`)
     }
    }> 

ejemplo con objectos y un solo if

<const tipoDeSuscripciones = {
    free: 'solo puedes tomar los cursos gratis',
    basic: 'puedes tomar casi todos los cursos de platzi durante un ano',
    expert: 'puedes tomar casi todos los cursos de platzi durante un ano',
    expertduo: 'Tu y alguien mas pueden tomar todos los cursos de platzi durante un ano'
  };

  function conseguirTipoSuscripcion(suscripcion) {
      if(tipoDeSuscripciones[suscripcion]) {
          console.log(tipoDeSuscripciones[suscripcion]);
          return;
      }
      console.warn('Ese tipo de suscripcion no existe')
  }
  conseguirTipoSuscripcion('free');> 

Yo lo hice con objetos :

let miSuscripcion = "ExpertPlus";


let tipoDeSuscripcion = {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 (suscripcion in tipoDeSuscripcion) {
    if (miSuscripcion == suscripcion) {
        console.log(tipoDeSuscripcion[suscripcion]);
    }
}

Mi forma de solucionar el ejercicio bonus 馃槃

var free = {nombre: "Free", info:"Solo puedes tomar los cursos gratis"}
var basic = {nombre: "Basic", info:"Puedes tomar casi todos los cursos de Platzi durante un mes"}
var expert = {nombre: "Expert", info: "Puedes tomar casi todos los cursos de Platzi durante un a帽o"}
var expertPlus = {nombre: "ExpertPlus", info:"T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"}
var listaTipoSub = [free,basic,expert,expertPlus];
var usertipo = "Expert";
for (var tipo of listaTipoSub){
 if (tipo.nombre == usertipo){
    console.log(`El plan que tienes es ${tipo.nombre} y ${tipo.info}`);
 }
}

Me pasa que como vengo de Python, autom谩ticamente pienso que est谩 creando un diccionario. Despu茅s me tengo que auto-corregir y decir, no es un diccionario es un objeto! Me cuesta mucho trabajar con diccionarios en Python, sobre todo crearlos a partir de archivos de tipo csv o txt que requieren de la creaci贸n de diccionarios anidados. Es una tortura! aunque me gusta. Espero que javascript me ayude un poco m谩s con esto.

驴Tienen alguna idea de alg煤n curso espec铆fico para esto?

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. 馃槒

Soluci贸n:

let sub = prompt("Ingrese subscripci贸n: ");

const objeto = {
    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",
    ExpertDuo: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o",
}


//objeto.Free
//objeto[variable]

function algo(parametro){
    for (key in parametro){
        if (key === sub){
            console.log(parametro[sub])
            return
        }
    }
    console.warn('Subscripcion errnea...')
}

algo(objeto)

Nota: Quitando la funci贸n igual corre bien

function beneficiosDeMiSub(resp_user){
  suscipriones[resp_user]
    ? console.log(suscipriones[resp_user])
    : console.warn("Lo siento, no te entend铆 :( ");
}

Yo quis茅 probar el desafio haciendo uso de arrays, s贸lo por no dejar xD
Est茅 fu茅 mi resultado:

const arrFruits = [
[鈥榤anzana鈥, 鈥楤uena elecci贸n, es dulce y nutritiva鈥橾,
[鈥榥aranja鈥, 鈥楤uena elecci贸n, aunque puede ser un poco 谩cida鈥橾,
[鈥榤elon鈥, 鈥楳uy saludable鈥橾
]

function eleccionDeFruta(fruit){
arrFruits.forEach((fruta) => {
if(fruta[0] === fruit){
console.log(fruta[1])
}
return
})

console.log('Buena elecci贸n')

}

eleccionDeFruta(鈥榤anzana鈥)
//Buena elecci贸n, es dulce y nutritiva

eleccionDeFruta(鈥榥aranja鈥)
//Buena elecci贸n, aunque puede ser un poco 谩cida

eleccionDeFruta(鈥榤elon鈥)
//Muy saludable

eleccionDeFruta(鈥榦tra鈥)
//Buena elecci贸n

Una mejor manera de resolver el reto seria asi:

const subsTypes = {
  free: "Free message",
  basic: "Basic message",
  expert: "Expert message",
  expertDuo: "Expert Duo message"
}

function getSubsType(subscription) {
  if (subscription in subsTypes) {
    console.log(subsTypes[subscription])
  } else {
    console.warn("Warn message")
  }
}

Este video vale oro鈥 es algo sencillo pero que en programas super complejos podr铆a minimizar un proceso muy grande hecho con puros ifs anidados

Yo resolv铆 as铆 el bonus final pero estoy seguro que se puede simplificar m谩s.

const tiposSuscripcion = {
  "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",
  "ExpertDuo": "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o",
}

function imprimirMensaje(objSuscripciones, tipoSuscripcion){
  const arrKeys = Object.keys(objSuscripciones)
  
  if(arrKeys.includes(tipoSuscripcion)){
    const arrValues = Object.values(objSuscripciones)
    const index = arrKeys.indexOf(tipoSuscripcion)
    console.log(arrValues[index]);
    return;
  }

  console.info("La suscripci贸n no es valida")
}

imprimirMensaje(tiposSuscripcion, "Expert");

.
Salida

En mi caso, a帽ad铆 la variable fuera de la funci贸n con un prompt para que el usuario a帽adiese la opci贸n y 茅sta se impriera directamente sin tener que ponerla en el c贸digo

var suscripcion = prompt("Que tipo de suscripci贸n quieres");

function tipoSuscripcion(suscripcion){
    if(suscripcion == 'Free'){
        document.write("S贸lo puedes tomar cursos gratis");
    }

    if(suscripcion == 'Basic'){
        document.write("Puedes tomar casi todos los cursos gratis");
    }

    if(suscripcion == 'Expert'){
        document.write(" Puedes tomar casi todos los cursosde Platzi durante un a帽o ");
    }

    if(suscripcion == 'ExpertDuo'){
        document.write("T煤 y alguien m谩s pueden tomar todos los cursosde Platzi durante un a帽o ");
    }
}
tipoSuscripcion(suscripcion);
const tipoDeSuscripcion = "Expert";

tierSubscripciones = {
    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",
}
console.log(tierSubscripciones[tipoDeSuscripcion]);

Quise aceptar el reto de realizar el c贸digo con un solo if鈥 esta es mi propuesta:

let tiposDeSuscripcion = [
{nombre:"Free",
mensaje:"Solo puedes tomar los cursos gratis"},
{nombre:"Basic",
mensaje:"Solo puedes tomar los cursos gratis"},
{nombre:"Expert",
mensaje:"Solo puedes tomar los cursos gratis"},
{nombre:"ExpertDuo",
mensaje:"Solo puedes tomar los cursos gratis"},
]

function tipoSuscripcion(suscripcion){
    let tipoEncontrado= tiposDeSuscripcion.find((tipo)=>{
        return tipo.nombre == suscripcion;
    })
    if(tipoEncontrado !== undefined){
        console.log(tipoEncontrado.mensaje);
        return;
    }
    console.warn("Ingresa un tipo de suscripci贸n v谩lido");
}

tipoSuscripcion('Free');

Esta clase fue muy interesante a la hora de optimizar c贸digo con objetos y funciones 馃憣

Yo intent茅 esto con arrays, objetos y arrays con objetos usando una sola condicional:

  • Arrays con una condicional:
  • Con un objeto y una condicional:
  • Con un array con objetos:

Todos son bastante parecidos, pero intent茅 usar diferentes m茅todos 馃槂

Me encanta la metodolog铆a y la energ铆a del profe, saludos

function imprimirDescripcion(suscr){
	const suscripciones = ["Free", "Basic", "Expert","ExpertDuo"]
const descripciones = ["Solo puedes tomar los cursos gratuitos de platzi", "Puedes tomar casi todos los cursos", "Puedes tomar todos los cursos", "Tu y alguien mas pueden tomar todos los cursos de platzi"];
	for (let i = 0; i<4;i++){
	if (suscripciones[i] == suscr) {
			console.log(descripciones[i]);
		} 
	}
}




function imprimirDescripcion(suscr){
	const suscripciones = [
		{
			 nombre: "Free", 
			descripcion: "Solo puedes tomar los cursos gratuitos de platzi" 
		} , 
		{
			nombre: "Basic" ,
			descripcion: "Puedes tomar casi todos los cursos"
		}, 
            	{ 
			nombre: "Expert",
			descripcion: "Puedes tomar todos los cursos"
		},
		{ 
			nombre: "ExpertDuo",
			descripcion: "Tu y alguien mas pueden tomar todos los cursos de platzi"
		}
	];
	for (let i=0; i<4; i++){
	if (suscripciones[i].nombre == suscr) {
			console.log(suscripciones[i].descripcion);
		} 
	}
}

asi lo hice yo

const suscriptions = [
    {nombre: 'ExpertPlus', texto: 'T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o'},
    {nombre: 'Expert', texto: 'Puedes tomar casi todos los cursos de Platzi durante un a帽o'},
    {nombre: 'Basic', texto: 'Puedes tomar casi todos los cursos de Platzi durante un mes'},
    {nombre: 'Free', texto: 'Solo puedes tomar los cursos gratis'}
];
const find_suscription = (element_find) => {
    let tipoDeSuscripcion = suscriptions.find(function(texto) {
        return texto.nombre === element_find;   
    });
    if (tipoDeSuscripcion) {
        console.log(`Suscripcion ${tipoDeSuscripcion.nombre} ${tipoDeSuscripcion.texto}`);
    } else {
        console.log("No cuentas con una suscripcion, te invito a que adquieras una");
    }
}
find_suscription('ExpertPlus');
find_suscription('Expert');
find_suscription('Basic');
find_suscription('Free');
find_suscription('');

Lo hice diferente al video =(:

const objCond = {
Free : 鈥淪olo puedes tomar los cursos gratis鈥,
Basic : 鈥淧uedes tomar casi todos los cursos de Platzi durante un mes鈥,
Expert : 鈥淧uedes tomar casi todos los cursos de Platzi durante un a帽o鈥,
ExpertDuo : 鈥淭煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o鈥
}

function imprimirCondicional(obj){
arrClave = Object.keys(obj);
arrResp =Object.values(obj);
pregunta=prompt(鈥楥ual es tu suscripcion鈥);
let respuesta = pregunta;
for(let i=0; i < arrClave.length; i++){

	if (respuesta == arrClave[i]){
		console.log(arrResp[i]);
		return;
	}
}

}

Yo lo hice pensando en las suscripciones y usuarios como entidades y la funci贸n eval煤a si estas coinciden. De esta forma en un futuro si se crean mas suscripciones simplemente se pushea otro objeto al array de suscriptions.
Me fui un poco con la l贸gica de POO 馃槅

let suscriptions = [
  {
    type: "Free", 
    description: "Solo puedes tomar los cursos gratis"
  },
  {
    type: "Basic", 
    description: "Puedes tomar casi todos los cursos de Platzi durante un mes"
  },
  {
    type: "Expert", 
    description: "Puedes tomar casi todos los cursos de Platzi durante un a帽o"
  },
  {
    type: "ExpertPlus", 
    description: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"
  }
];

let user123 = {
  name: "Yerko",
  userName: "yerkodigo",
  email: "[email protected]",
  suscription: "Expert",
  getSuscription: function() {
    return this.suscription;
  }
};

const userSuscription = (obj) => {
  const result = suscriptions.find(e => e.type.toLowerCase() === obj.getSuscription().toLowerCase());

  if(result != undefined) {
    return `Hola ${obj.name}, tu suscripci贸n es: "${obj.getSuscription()}" ${result.description}`;
  }

  return "No cuentas con una suscripci贸n disponible.";
}

console.log(userSuscription(user123));

Puedo decir a toda honra, que mi soluci贸n era bastante 鈥渉ardcoded鈥 al ver la de JuanDC.

yo lo realice de la siguiente manera:

<function bonusPlatzi(eleccion) {
    let valorPlatzi = [
        { name: 'Free', descripcion: "Solo puedes tomar los cursos gratis" },
        { name: 'Basic', descripcion: "Puedes tomar casi todos los cursos gratis durante un mes" },
        { name: 'Expert', descripcion: "Puedes tomar casi todos los cursos gratis durante un a帽o" },
        { name: 'ExpertPlus', descripcion: "Puedes tu y otra persona tomar casi todos los cursos gratis durante un a帽o" },
    ]
    let result = valorPlatzi.filter(values => values.name === eleccion);
    console.log(`Haz elegido el plan ${eleccion}, es decir ${result[0].descripcion}`);
}
bonusPlatzi('Expert');>

Fenomenal el profesor

lo que mas me sorprende son las distintas forma de resolver una problematica, apesar de las pocas clases hasta en momento es increible el contenido.

este fue mi resultado

const tipoDeSubscripcion = "basic";
let planes = [
  { nombre: "free",
    descipcion: "Solo puedes tomar los cursoso gratis." },
  {
    nombre: "basic",
    descipcion: "Puedes tomar casi todo los cursos duerante un mes.",
  },
  {
    nombre: "expert",
    descipcion: "puedes tomar casi todos lo cursos durane un a帽o.",
  },
  {
    nombre: "expertPLus",
    descipcion:
      "t煤 y alguien m谩s pueden tomar todos los cursos de platzi durante un a帽o",
  },
];

function suscripcion(tipoDeSubscripcion) {
  for (let i = 0; i < planes.length; i++) {
    if (planes[i].nombre === tipoDeSubscripcion) {
      console.log(planes[i].descipcion);
    }
  }
}

Otra manera de鈥

// Con objetos 
const suscripciones = [
    {suscription:"Free" , msg:"Solo puedes tomar los cursos gratis" },
    {suscription:"Basic" , msg:"Puedes tomar casi todos los cursos de Platzi durante un mes"},
    {suscription:"Expert" , msg:"Puedes tomar casi todos los cursos de Platzi durante un a帽o"},
    {suscription:"ExpertPlus" , msg:"T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"}
];
let tipode = "Expert";

let tipoSuscripcion = suscripciones.find(function(suscript){
    if(suscript.suscription === tipode) console.log(suscript.msg);
});

mi soluci贸n

function tipoSuscripcion (tipo, texto) {
    this.tipo = tipo;
    this.texto = texto;
}

var tiposSuscripciones = [ 
    new tipoSuscripcion("Free","Solo puedes tomar los cursos gratis"), 
    new tipoSuscripcion("Basic","Puedes tomar casi todos los cursos de Platzi durante un mes"),
    new tipoSuscripcion("Expert","Puedes tomar casi todos los cursos de Platzi durante un a帽o"),
    new tipoSuscripcion("ExpertPlus","T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o")
]

function buscaTipoSuscripcion(suscripcion){
    let tipoResultado = tiposSuscripciones.find(tipoSuscripcion => tipoSuscripcion.tipo === suscripcion);
    if (tipoResultado) 
        return tipoResultado.texto
    return "No existe este tipo de suscripcion";
}

LLamadas y salidas

  • console.log(buscaTipoSuscripcion("Free"));
    • Solo puedes tomar los cursos gratis
  • console.log(buscaTipoSuscripcion("Fr"));
    • No existe este tipo de suscripcion
  • console.log(buscaTipoSuscripcion("Basic"));
    • Puedes tomar casi todos los cursos de Platzi durante un mes
  • console.log(buscaTipoSuscripcion("Expert"));
    • Puedes tomar casi todos los cursos de Platzi durante un a帽o
  • console.log(buscaTipoSuscripcion("ExpertPlus"));
    • T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o

Me encanto este video, me costaba mucho entender lo de los condicionales pero ya todo me esta quedando mucho m谩s claro!.
Que bueno explicaci贸n 馃槂

Este video es un punto de inflexi贸n, el mundo de posibilidades en infinito, vengo de aprender llava que es tan estricto.

Soluciones que realice antes y modificadas con la gu铆a del video de Platzi y agregando PROMT para que el usuario ingrese el valor y se valide.


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


let tipoDeSuscripcion2 = prompt (" 驴Qu茅 tipo de suscripcion tienes?  Free, Basic, Expert, ExpertPlus")


if (tipoDeSuscripcion2 === "Free" || "Basic" || "Expert" || "ExpertPlus" ) {
    document.write("Bienvenido a Platzi");
    
}




//SOLUCION DE PLATZI con SOLO IF Y RETURN


let tipoDeSuscripcion3 = prompt (" 驴Qu茅 tipo de suscripcion tienes?  Free, Basic, Expert, ExpertPlus")


function validarSuscripcion (tipoDeSuscripcion3){
if (tipoDeSuscripcion3 === "Free"){
    document.write("Solo puedes tomar los cursos gratis");
    return   // El return perimte cortar el if  al terminar y no se ejecute el codigo sobrante dentro de la funcion 
}

if (tipoDeSuscripcion3 === "Basic"){
    document.write("Puedes tomar casi todos los cursos de Platzi durante un mes");
   return
}

if (tipoDeSuscripcion3 === "Expert"){
    document.write("Puedes tomar casi todos los cursos de Platzi durante un a帽o");
    return
}

if (tipoDeSuscripcion3 === "ExpertPlus"){
    document.write("T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o");
    return
}


 
console.warn("Ingresa valores validos")   /// sale un aviso en la consolola subrayyado en amarillo
    
}


validarSuscripcion (tipoDeSuscripcion3)






//馃挕 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. 馃槒


// Solucion de Platzi mas una elemento de entrada del ususario con prompt

let tipoDeSuscripcion4 = prompt (" 驴Qu茅 tipo de suscripcion tienes?  free, basic, expert, expertPlus")

let tipoSuscripcionPlatzi = { 


    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: "Puedes tomar casi todos los cursos de Platzi durante un a帽o"

}


function validarSuscripcion1 (suscripcion){

    if(tipoSuscripcionPlatzi [suscripcion]){
        alert(tipoSuscripcionPlatzi[suscripcion])
        return


    }


}


validarSuscripcion1(tipoDeSuscripcion4)



Mi m茅todo usando lo de las clases pasadas para usar un solo If, igual el objeto estuvo de m谩s, pero es solo para practicar 馃槃

const suscripciones = {

    tipo: ['Free',
	   'Basic',
	   'Expert',
	   'ExpertDuo'],

    descripcion: ['Solo puedes tomar los cursos gratis',
                  'Puedes tomar casi todos los cursos durante un mes',
                  'Puedes tomar casi todos los cursos durante un a帽o',
                  'Tu y alguien m谩s pueden tomar TODOS los cursos durante un a帽o'],
}

function mostrarSuscripcion(sus){
    const indexSus = Object.values(suscripciones);
    const tipoSus = indexSus[0];
    const indicaSus = indexSus[1];
    for (let i=0; i<tipoSus.length; i++){
        if(sus == tipoSus[i]){
            console.log(indicaSus[i]);
	    return;
        }
    }
    console.warn('Ese tipo de suscripci贸n no existe :o');
}

mostrarSuscripcion('ExpertDuo');

MI soluci贸n

let tipoDeSuscripcion = "ExpertPlus";

let suscripciones= [
		{
			suscripcion: 'basic',
			mensaje: 'puedes tomar casi todos los cursos de Platzi durante un mes'
		},{
			suscripcion: 'Free',
			mensaje: 'Solo puedes tomar los cursos gratis'
		},
		{
			suscripcion: 'ExpertPlus',
			mensaje: 'T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o'
		},
		{
			suscripcion: 'Expert',
	    mensaje: 'Puedes tomar casi todos los cursos de Platzi durante un a帽o'
		}
];


suscripciones.forEach(x => {
    if(x.suscripcion == tipoDeSuscripcion){
        console.log(x.mensaje);
    }
})

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

  • Mi soluci贸n:
let inputPrompt = prompt("驴Cual es tu plan Platzi?  Free=0  Basic=1  Expert=2  ExpertDuo=3");
let encenderCondicional = true;
let planPlatzi = {
    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",
    expertDuo: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"
}
if(encenderCondicional) {
    let resultado = Object.values(planPlatzi);
    alert(resultado[inputPrompt]);
    encenderCondicional = false;
}

Yo lo hab铆a resuelto as铆:


var suscripcion = {
    1: "Free",
    2: "Basic",
    3: "Expert",
    4: "Expert Plus"
}
var info_suscripcion = {
    1: "S贸lo puedes tomar los cursos gratis",
    2: "Puedes tomar casi todos los cursos de Platzi durante un mes",
    3: "Puedes tomar todos los cursos de Platzi durante un a帽o", 
    4: "T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"
}
console.log("Men煤 de suscripciones: "); 
console.log("1: Free"); 
console.log("2: Basic"); 
console.log("3: Expert"); 
console.log("4: ExpertPlus"); 
var resp = prompt("Escribe el n煤mero que corresponda a tu suscripci贸n: "); 
var respuesta = Number(resp); 
console.log("Tu tipo de suscripci贸n es: " + suscripcion[respuesta]);
console.log("Y con ella: " + info_suscripcion[respuesta]);

Creo que ten铆a la idea, pero por supuesto que el del profe es mejor porque usa funciones y est谩 m谩s organizado.

<function coseguirTipo(tipo){

    var suscripcion = {
        free:"Solo puedes tomar los cursos gratis",
        basic:"Puedes tomar caso todos los cursos de Platzi durante un mes",
        expert:"Puedes tomas casi todos los cursos de Platzi durante un a帽o",
        expertduo: "Tu y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"
    }

    var array =  Object.keys(suscripcion);

    if(array.includes(tipo)){
        return suscripcion[tipo.toLowerCase()];
    }else{
        return "Este tipo de  suscripcion no existe"
    }
  
}> 

Mi soluci贸n

"use strict";
function tipoDeSuscripcion (seleccion){
const suscripcion = {
  Free : "Solo puedes tomar los cursos gratis",
  Basic : "Puedes tomar casi todos los cursos de Platzi durante un me",
  Expert : "Puedes tomar 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",
};

  if (Object.keys(suscripcion).includes(seleccion)){
    console.log(suscripcion[seleccion])
    return;
  }
  console.warn("脡se tipo de suscrpci贸n no existe");
}

let seleccion =  "Expert";

tipoDeSuscripcion(seleccion);

Resolv铆 la prueba y tuve algunos errores, pero que bueno que lo explicaron as铆 me queda m谩s claro los conceptos.
Me gusta que hayan reformulado el curso anterior, yo lo lleve y si bien lo entend铆, me quedo la gran duda de como integrarlo con HTML, cuando lleve el curso pr谩ctico de API rest reci茅n entend铆 que lo que me faltaba era manipulaci贸n del DOM, espero poder aprender lo b谩sico con este curso para poder profundizar el tema.

Interesante lo del return

Soluci贸n al desaf铆o de condicionales:

// Utilizando un objeto
function getSubscriptionUsingObject(subscription) {
  const subs = {
    free: "Solo puedes tomar los cursos gratis",
    basic: "Puedes tomar casi todos los cursos de Platzi durante un mes",
    expert: "Puedes tomar todos los cursos de Platzi durante un a帽o",
    expertDuo: "T煤 y alguien m谩s pueden tomar todos los cursos de Platzi durante un a帽o"
  }
  
  if (Object.keys(subs).includes(subscription)) {
  	console.log(subs[subscription])
    return;
  }
  
  console.log("Ese tipo de suscripci贸n no existe")
}

// Utilizando arreglos y higher-order functions
function getSubscriptionUsingArrays(subscription) {
	const plans = ["free", "basic", "expert", "expertDuo"]
  const descriptions = ["Solo puedes tomar los cursos gratis", "Puedes tomar casi todos los cursos de Platzi durante un mes", "Puedes tomar 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 (plans.includes(subscription)) {
  	console.log(descriptions[plans.findIndex(element => element === subscription)])
    return;
  }
  
  console.log("Ese tipo de suscripci贸n no existe")

} 

Buenas, yo lo hice de esta manera:

Coloque un objeto dentro de un array y luego se busca ese objeto por nombre .

const suscripciones = [
    {name: 'one', mensaje: "Te puedes suscribir tu solo"},
    {name: 'duo', mensaje: "Se pueden suscribir ambos"}
]; 


function consultar (suscripcion){
    if(suscripcion){
        let resultado = suscripciones.find( susc => susc.name === suscripcion );
        console.log(resultado.mensaje);
        return;
    }
    console.log("No existe")
}

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);
        }
    }
}

yo lo resolvi pensando el problema como si fueran una lista de estudiantes y revisando sus pases

const tipoDeSuscripcion = "Basic";

var listaestudiante = [
    {name: 'juan', plan: 'Basic', age: 18, msj:"Puedes tomar casi todos los cursos de Platzi durante un mes"},
    {name: 'aurora', plan: 'expert', age: 18, msj:"Puedes tomar casi todos los cursos de Platzi durante un a帽o"},
    {name: 'luz', plan: 'Basic', age: 18, msj:"Puedes tomar casi todos los cursos de Platzi durante un mes"},
    {name: 'maria', plan: 'free', age: 18, msj:"Solo puedes tomar los cursos gratis"},
    {name: 'fernado', plan: 'expert', age: 18, msj:"Puedes tomar casi todos los cursos de Platzi durante un a帽o"},
    {name: 'otrojuan', plan: 'Basic', age: 18, msj:"Puedes tomar casi todos los cursos de Platzi durante un mes"},
    {name: 'juancaballo', plan: 'expertPlus', msj: 18, msj:"T煤 y alguien m谩s pueden tomar TODOS los cursos de Platzi durante un a帽o"}
]

listaestudiante.map(item => {
    if(item.plan == tipoDeSuscripcion)
    {
        console.log(item.msj)
    }
})
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: 鈥渇reee鈥,
expert:鈥渆xpertt鈥
}
var dato = 鈥渇ree鈥 //este dato cambia por consola o como quieras
if(suscripciones[dato]){
console.log(suscripciones[dato])
}else console.log(鈥淣o 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");
}