Bonus: reducción de condicionales

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

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á “Puedes 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 “nombre” y la “descripció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 😃

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 = ‘Basic’;
validarSus(suscripcion);
function validarSus(suscripcion){
if( suscripcion == ‘Basic’ ){
console.log(‘Tomas Cursos Gratis’);
}
else if(suscripcion == ‘Medium’){
console.log(‘Tomas Cursos Durante 5 Meses’);
}
else if(suscripcion == ‘Unli’){
console.log(‘Tomas todos los Cursos durante un anio’);
}
else{
console.log(‘Lo 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 = [“Free”,“Basic”,“Expert”,“ExpertPlus”];

if (tipoDeSucripcion.indexOf(“Basic”) == true) {
console.log(“Puedes 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 año','Tu y alguien mas pueden tomar TODOS los cursos durante 1 año');
    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 “return” 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 errónea...')
}

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 = [
[‘manzana’, ‘Buena elección, es dulce y nutritiva’],
[‘naranja’, ‘Buena elección, aunque puede ser un poco ácida’],
[‘melon’, ‘Muy saludable’]
]

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

console.log('Buena elección')

}

eleccionDeFruta(‘manzana’)
//Buena elección, es dulce y nutritiva

eleccionDeFruta(‘naranja’)
//Buena elección, aunque puede ser un poco ácida

eleccionDeFruta(‘melon’)
//Muy saludable

eleccionDeFruta(‘otra’)
//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 : “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 imprimirCondicional(obj){
arrClave = Object.keys(obj);
arrResp =Object.values(obj);
pregunta=prompt(‘Cual es tu suscripcion’);
let respuesta = pregunta;
for(let i=0; i < arrClave.length; i++){

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

}

Mis apuntes de este curso en Notion

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 “hardcoded” 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: “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");
}