Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Encapsulando código en funciones

7/24
Recursos

Aportes 143

Preguntas 14

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

si quisieramos simplificar aún mas nuestro código podemos usar arrow functions 😃

El resultado sería el siguiente:

// Cuadrado
const perimetroCuadrado = (lado) => lado * 4;
const areaCuadrado = (lado) => lado * lado;

// Triángulo
const perimetroTriangulo = (lado1, lado2, base) => lado1 + lado2 + base;
const areaTriangulo = (base, altura) => (base * altura) / 2;

// Circulo
const diametroCirculo = (radio) => radio * 2;
const PI = Math.PI;
const perimetroCirculo = (radio) => diametroCirculo(radio) * PI;
const areaCirculo = (radio) => PI * radio ** 2;

Dato curioso de la clase: cuando declaramos la funcion los datos dentro de los parentesis se llaman PARAMETROS, cuando llamamos a ejecutarla se llaman ARGUMENTOS.

Para comentar un bloque de código completo:

  • Seleccionar el bloque a comentar.
  • Ctrl + K (y sin soltar la tecla Ctrl) + C

Espero les sirva este atajo de Visual Studio Code.

Código hecho en TypeScript:

//* Código del cuadrado
const perimetroCuadrado = (lado: number): number => {
  return lado * 4;
}

const areaCuadrado = (lado: number): number => {
  return Math.pow(lado, 2);
}

//*Código del triángulo
const perimetroTriangulo = (lado1: number, lado2: number, base: number): number => {
  return lado1 + lado2 + base;
}

const areaTriangulo = (base: number, altura: number): number =>{
  return (base*altura) / 2;
}

//* Código del círculo
const perimetroCirculo = (diametro: number): number => {
  return Math.pow(Math.PI, 2) * diametro;
}

const areaCirculo = (radio: number): number => {
  return Math.PI * Math.pow(radio, 2);
}

Algunos de mis apuntes del curso. 😋

Por fin pude entender las funciones, por alguna razón se me complicó muchísimo. Que excelente profesor.

Increíble y fundamental el poder de las funciones. 😃

Mi código de la clase:

// Funciones que encapsulan las funcionalidades de cuadrado
function perimetroCuadrado(lado) {
    return lado > 0 ? lado * 4 : 'Ingresar un valor válido'
}

function areaCuadrado(lado) {
    return lado > 0 ? lado * lado : 'Ingresar un valor válido'
}

// Funciones que encapsulan las funcionalidades de triángulo
function perimetroTriangulo(lado1, lado2, base) { 
    return lado1 > 0 & lado2 > 0 & base > 0 ? lado1 + lado2 + base : 'Ingresar valores válido'
}

function areaTriangulo(altura, base) { 
    return altura > 0 & base > 0 ? (base * altura)/2 : 'Ingresar valores válido'
}

// Funciones que encapsulan las funcionalidades de círculo
function diametroCirculo(radio) {
    return radio > 0 ? radio * 2 : 'Ingresar un valor válido'
}

function perimetroCirculo(radio) {
    const diametro = diametroCirculo(radio)
    return radio > 0 ? diametro * Math.PI  : 'Ingresar un valor válido'
}

function areaCirculo(radio) {
    return radio > 0 ? (radio * radio) * Math.PI : 'Ingresar un valor válido'
}

A mi código le agregue una función que calcula la altura de un triángulo por si le quieren echar un vistazo ^^ Son solo metodos de la librería Math…

//Código del Cuadrado
console.group("Cuadrados");

const perimetroCuadrado = (lado) => lado * 4; //Arrow Function
const areaCuadrado = (lado) => lado ** 2; //Otra forma de elevar un número a un exponente, en este caso 2 (al cuadrado)

console.log(`Los lados del cuadrado miden 6cm`);
console.log(`Calculando el perímetro del cuadrado: ${perimetroCuadrado(6)}cm`);
console.log(`Calculando el área del cuadrado: ${areaCuadrado(6)}cm^2`);

console.groupEnd();

//Código del Triángulo
console.group("Triángulos");

const alturaTriangulo = (lado, base) => {
  const angulo = Math.acos(base / 2 / lado); //Obtiene el ángulo formado en radianes
  return lado * Math.sin(angulo); //Devuelve la altura
};
const perimetroTriangulo = (lado, base) => lado * 2 + base;
const areaTriangulo = (base, altura) => (base * altura) / 2;

console.log(`Los lados del triángulo miden 6cm, 6cm y 4cm de base`);
console.log(`Calculando la altura del Triángulo: ${alturaTriangulo(6, 4)}cm`);
console.log(
  `Calculando el perímetro del Triángulo: ${perimetroTriangulo(6, 4)}cm`
);
console.log(
  `Calculando el área del Triángulo: ${areaTriangulo(
    6,
    alturaTriangulo(6, 4)
  )}cm`
);

console.groupEnd();

//Código de los Círculos
console.group("Círculos");

const radioCirculo = 8;
const PI = Math.PI;

const diametroCirculo = (radio) => radio * 2;
const perimetroCirculo = (radio) => diametroCirculo(radio) * PI;
const areaCirculo = (radio) => radio ** 2 * PI;

console.log(`El radio del Círculo es de ${radioCirculo}cm`);
console.log(
  `Calculando el diámetro del Círculo: ${diametroCirculo(radioCirculo)}cm`
);
console.log(
  `Calculando el perímetro del Círculo: ${perimetroCirculo(radioCirculo)}cm`
);
console.log(`Calculando el área del Círculo: ${areaCirculo(radioCirculo)}cm^2`);

console.groupEnd();

Estaría bien que el profe hiciera solo un ejemplo y que nosotros hagamos lo demás como reto. Si no luego se vuelve aburrida la clase

Si queremos ahorrarnos hacer nuestro código lo mas simple posible podemos usar arrow functions de esta forma:

// Código del cuadrado
const perimetroCuadrado = lado => lado * 4
const areaCuadrado = lado => lado * lado

// Código del triangulo
const perimetroTriangulo = (lado1, lado2, base) => lado1 + lado2 + base
const areaTriangulo = (base, altura) => (base * altura) / 2

// Código del circulo
const perimetroCirculo = radio => 2 * Math.PI * radio
const areaCirculo = radio => Math.PI * radio * radio

No es necesario utilizar la sentencia return porque son arrows functions de una sola linea, estas funciones son similares a las funciones lambda de otros lenguajes (ej. Python)

EN JS existen las funciones flechas , estas en muchos casos son muy útiles , les dejo esta lectura por si alguien le interesa el tema

LINK

Aquí pueden ver un ejemplo:

Posdata: La imagen no es mía la saque de internet JAJAJA)

Lo pude optimizar bastante con las arrow functions 😄

7. Encapsulando código en funciones

¿Qué es una función?

Las funciones son como un conjunto de sentencias para realizar ciertas tareas o acciones y en ellas se puede hacer el uso de las variables

Funciones Declarativas

Las funciones declarativas son aquellas que expresamente se declara con la palabra reservada funtion seguida el del nombre y sus parámetros.

Sintaxis funciones declarativas

function [name]([param1, param2, ..., paramN]) {
   statements
}

Ejemplo de una función declarativa


// Declaración de una Funcion Declarativa
function saludar() {
    console.log('Saludando desde una función declarativa');
}
//llamada de la función declarativa
saludar();
 

llamar funciones dentro de otras funciones

También puede darse la situación de que se pueda llamar una función dentro de otra función

Ejemplo:


// Círculo
console.group('Círculo');

const PI = Math.PI;
const circuloRadio = 4;

function fn_circuloDiametro(p_circuloRadio) {
	return p_circuloRadio * PI;
}

//llamando una función dentro de otra función
function fn_circuloArea(p_circuloRadio) {
	// es equivalente a = p_circuloRadio *  p_circuloRadio * PI
	return fn_circuloDiametro( p_circuloRadio) * p_circuloRadio;
}

const circuloDiametro = fn_circuloDiametro(circuloRadio);
const circuloArea = fn_circuloArea(circuloRadio);

console.log('La constante PI es de: ' + PI);
console.log('El radio del círculo mide ' + circuloRadio + 'cm');
console.log('El diametro del circulo es : ' + circuloDiametro + 'cm');
console.log('El área triángulo mide: ' + circuloArea + 'cm^2');

console.groupEnd();

funciones como argumentos de una función

En javascript se puede enviar funciones como argumentos de otras funciones.

function fn_sumar(num1, num2, respuesta) {
	respuesta = num1 + num2;
	console.log(`El resultado de la suma es: ${respuesta}`);
}

function datos_de_suma(fn_sumar) {
	var num1 = 5;
	var num2 = 6;
	var respuesta;
	if (fn_sumar) {
		//la función es invocada o ejecutada
		fn_sumar(num1, num2, respuesta); 
	}
}

// se pasa la referencia de  la función. No es una invocación
datos_de_suma(fn_sumar); 

Otro ejemplo de funciones por argumentos

class Persona {
	constructor(nombre, apellido, altura) {
		this.nombre = nombre;
		this.apellido = apellido;
		this.altura = altura;
	}
	saludar(fn_responderSaludo) {
		//de-estructuracion
		// var nombre = this.nombre
		// var apellido = this.apellido
		var { nombre, apellido } = this;
		console.log(`Hola, me llamo ${nombre} ${apellido}`);
		if (fn_responderSaludo) {
			//la función es invocada
			fn_responderSaludo(nombre, apellido, false); 
		}
	}
}

class Desarrollador extends Persona {
	constructor(nombre, apellido, altura) {
		super(nombre, apellido, altura);
	}
	saludar(fn_responderSaludo) {
		//de-estructuracion
		// var nombre = this.nombre
		// var apellido = this.apellido
		var { nombre, apellido } = this;
		console.log(
			`Hola, me llamo ${nombre} ${apellido} y soy desarrollador/a`
		);
		if (fn_responderSaludo) {
			// la función es invocada
			fn_responderSaludo(nombre, apellido, true); 
		}
	}
}

// función que se pasará por parámetro
function responderSaludo(nombre, apellido, esDev) {
	console.log('==================');
	console.log('Respondiendo Saludo');
	console.log(`Buen día ${nombre} ${apellido}`);
	if (esDev) {
		console.log(
			`Eres desarrollador/a, 
			¡Que bueno! podemos hablar de muchos temas (^.^)`
		);
	} else {
		console.log(
			`No eres desarrollador/a, 
			pero igual podemos conversar de otros temas (^.^)`
		);
	}
	console.log('______________________________________________');
}

var sacha = new Persona('Sacha', 'Lifszyc', 1.72);
var erika = new Persona('Erika', 'Luna', 1.65);
var arturo = new Desarrollador('Arturo', 'Martinez', 1.89);

// Se  pasa la referencia de  la función. No es una invocación
sacha.saludar(responderSaludo);
// Se  pasa la referencia de  la función. No es una invocación 
erika.saludar(responderSaludo); 
// Se  pasa la referencia de  la función. No es una invocación
arturo.saludar(responderSaludo); 

Programción del taller 1 : parte 2

// Cuadrado
console.group('Cuadrado');

const cuadradoLado = 5;

function fn_cuadradoPerimetro(p_cuadradoLado) {
	return p_cuadradoLado * 4;
}

function fn_cuadradoArea(p_cuadradoLado) {
	return p_cuadradoLado * p_cuadradoLado;
}

const cuadradoPerimetro = fn_cuadradoPerimetro(cuadradoLado);
const cuadradoArea = fn_cuadradoArea(cuadradoLado);

console.log('Los lados del cuadro mide: ' + cuadradoLado + 'cm');
console.log('El perímetro del cuadro mide: ' + cuadradoPerimetro + 'cm^2');
console.log('El área del cuadro mide: ' + cuadradoArea + 'cm^2');

console.groupEnd();

//Triángulo
console.group('Triángulo');

const trianguloLado_a = 6;
const trianguloLado_b = 6;
const trinaguloBase = 4;
const trianguloAltura = 5.5;

function fn_trainguloPerimetro(
	p_trainguloLado_a,
	p_trainguloLado_b,
	p_trainguloLado_base
) {
	return trianguloLado_a + trianguloLado_b + trinaguloBase;
}

function fn_trianguloArea(p_trianguloBase, p_trianguloAltura) {
	return (p_trianguloBase * p_trianguloAltura) / 2;
}

const trianguloPerimetro = fn_trainguloPerimetro(
	trianguloLado_a,
	trianguloLado_b,
	trinaguloBase
);
const trianguloArea = fn_trianguloArea(trinaguloBase, trianguloAltura);

console.log('El lado A del triángulo a mide: ' + trianguloLado_a + 'cm,');
console.log('El lado B del triángulo b mide: ' + trianguloLado_b + 'cm,');
console.log('La base o lado C del triángulo mide: ' + trinaguloBase + 'cm');
console.log('La altura del triángulo mide: ' + trianguloAltura + 'cm');
console.log('El perímetro del triángulo mide: ' + trianguloPerimetro + 'cm');
console.log('El area triángulo mide: ' + trianguloArea + 'cm^2');

console.groupEnd();

// Círculo
console.group('Círculo');

const PI = Math.PI;
const circuloRadio = 4;

function fn_circuloDiametro(p_circuloRadio) {
	return p_circuloRadio * PI;
}

function fn_circuloArea(p_circuloRadio) {
	return p_circuloRadio * p_circuloRadio * PI;
}

const circuloDiametro = fn_circuloDiametro(circuloRadio);
const circuloArea = fn_circuloArea(circuloRadio);

console.log('La constante PI es de: ' + PI);
console.log('El radio del círculo mide ' + circuloRadio + 'cm');
console.log('El diametro del circulo es : ' + circuloDiametro + 'cm');
console.log('El área triángulo mide: ' + circuloArea + 'cm^2');

console.groupEnd();

¡Hola Platzinautas! 👋🏽
No saben lo que le he sufrido a las funciones, es de lo más complicado que he estudiado. 😂 Juan David es un profesor excelente, gracias a él logré comprenderlas, les comparto mis apuntes. Y pueden ver más apuntes en https://byiris.netlify.app

Así quedó mi código utilizando funciones flechas:

const perimeterSquare = (sideSquare) => sideSquare * 4;
const areaSquare = (sideSquare) => sideSquare ** 2;

// Triangle
const trianglePerimeter = ({ sideA, sideB, base }) => sideA + sideB + base;
const triangleArea = ({ base, height }) => (base * height) / 2;

// Circle
const circleDiameter = (radius) => radius + radius;
const circlePerimeter = (radius) => circleDiameter(radius) * Math.PI;
const circleArea = (radius) => radius * radius * Math.PI;

Cuando dentro de las “Funciones” recibimos parametros las llamamos asi! Parametros,… Cuando llamamos a una function lo que enviamos se llama Argumentos
Se puede llamar a una Function dentro de otra function creando una Variable dentro de ella, que llame un parametro con ‘X?’ valor… recuerda que esta variable solo podemos ejecutarla dentro de la function… Corrijanme si entendi mal 😃

mi solucion antes de la clase 😃

Diferencias entre parámetro y argumento.

  • Los parámetros son los datos que se reciben cuando se declara una función, los argumentos son los datos que se envían cuando se manda a llamar una función.

IMPRIMIR DIRECTO AL NAVEGADOR

/---------PERIMETRO Y AREA DE UN CUADRADO------/

var ladoCuadrado = prompt(“Ingresa el valor de uno de los lados del cuadrado”);

document.write(
“El cada lado del cuadrado mide " + ladoCuadrado + " cm”
+
" El area de tu cuadrado es: " + ladoCuadradoladoCuadrado + " cm"
+
" y el perimetro es: " + ladoCuadrado
4 + " cm cuadrados"
);

/----PERIMETRO Y AREA DE UN TRIUANGULO----/

var trianguloL__uno = parseInt(prompt(“Cual es el valor del primer lado del triangulo”));
var trianguloL__dos = parseInt(prompt(“Cual es el valor del segundo lado del triangulo”));
var trianguloL__base = parseInt(prompt(“Cual es el valor de la base del triangulo”));
var trianguloL__h = parseInt(prompt(“Cual es el valor de la altura del triangulo”));

document.write(
“El area de tu triangulo es " + trianguloL__base*trianguloL__h/2 + " cm cuadrados”
+
" y su perimetro es " + (trianguloL__uno + trianguloL__dos + trianguloL__base) + " cm"
);

/PERIMETRO Y AREA DE UN CIRCULO/

var radio = parseInt(prompt(“Cual es el radio de tu circulo”));

document.write(
“El area de tu circulo es " +
(radioradio * Math.PI ) +
" Cm^2" +
" y su Perimetro es: " +
(2
Math.PI*radio) +
” Cm^2"
);

reduciendo un poco el codigo… #JSChallenge

// Cuadrado

console.group("Cuadrado");

const perimetroCuadrado = (lado) => lado * 4 
const areaCuadrado = (lado) => lado**2

console.log(`Perimetro ${perimetroCuadrado(5)}`);
console.log(`Area ${areaCuadrado(5)}`);

console.groupEnd();

// Triangulo
console.group("Trangulo");

const perimetroTriangulo = (lado1, lado2, base) => lado1 + lado2 + base;
const areaTriangulo = (base, altura) => (base * altura) / 2;

console.log(`Perimetro ${perimetroTriangulo(6, 6, 4)}`);
console.log(`Area ${areaTriangulo(4, 5.5)}`);

console.groupEnd();

// Circulo
console.group("Circulo");

const perimetroCirculo = (radio) => (radio * 2) * Math.PI;
const areaCirculo = (radio) => (radio**2) * Math.PI;

console.log(`perimetro ${perimetroCirculo(4)}`);
console.log(`area ${areaCirculo(4)}`);

console.groupEnd();

En el caso del perimetroTriangulo y areaTriangulo, no siempre todos los lados van a ser distintos, ya que por ejemplo, el triangulo equilátero todos los lados son iguales y en el equilátero dos lados son iguales mientras que uno es la base. Por eso, estas funciones deberían ser de la siguiente manera:

function perimetroTriangulo(base, lado1, lado2){
  if(lado2){
    return base + lado1 + lado2;
  }else{
    if(lado1){
      return base + (lado1 * 2)
    }else{
      return base * 3
    }
  }
}

perimetroTriangulo(5) //15
perimetroTriangulo(7, 5) //17
perimetroTriangulo(5, 8, 9) //22

Con objetos se hace más sencillo.

//cuadrado

const cuadrado = (lado) => {
  let value = {
    perimetro: lado * 4,
    area: lado ** 2
  };

  return value;
}

//triangulo

const triangulo = (ladoA, ladoB, base, altura) => {
  let value = {
    perimetro: ladoA + ladoB + base,
    area: (base * altura) / 2
  };

  return value
}

//circulo

const circulo = (diametro) => {
  let radio = diametro / 2;
  let value = {
    circunferencia: diametro * Math.PI,
    area: parseFloat(((radio ** 2) * Math.PI).toFixed(2))
  }

  return value
}

Excelente clase, la forma de explicar de JuanDC es muy clara. 👨🏻‍💻

Mi forma de hacerlo fue un poco distinta pues opte mejor por encapsular las figuras geométricas en una función por cada una , haciendo uso de arrow functions para mirificar mas mi código


// Codigo del cuadrado

const Cuadrado = (lado)=>{
    const perimetro_cuadrado = lado*4;
    const area_cuadrado = lado*lado;

    console.group('Cuadrado');//Permite agrupar console.logs en un grupo especifico

    console.log(`Los lados del cuadrado miden: ${lado} cm`);
    console.log(`El perimetro del cuadrado es: ${perimetro_cuadrado} cm`);
    console.log(`El area del cuadrado es: ${area_cuadrado} cm^2`);

    console.groupEnd();//Cierra el agrupamiento de console.log

}

//Codigo del triangulo

const Triangulo = (lado1, lado2, lado3, altura)=>{

    const perimetro_triangulo = lado1+lado2+lado3;
    const area_triangulo = (lado1*altura) /2;

    console.group('Triangulo');

    console.log(`Los lados del triangulo miden: ${lado1}cm, 		 ${lado2}cm, ${lado3}cm`);
    console.log(`La altura del triangulo es: ${altura}`);
    console.log(`El perimetro del triangulo es: ${perimetro_triangulo}cm`);
    console.log(`El area del triangulo es: ${area_triangulo}cm^2`);

    console.groupEnd();

}

//Codigo del circulo

const Circulo = (radio) =>{
    const diametro = radio*2;
    const Pi = Math.PI;
    const perimetro = diametro * Pi;
    const area = Pi * (radio*radio);


    console.group('Circulos');
    
    console.log(`El diametro del ciculo es: ${diametro}cm, y su radio es: ${radio}cm`);
    console.log(`El perimetro del circulo es: ${perimetro}cm`);
    console.log(`El area del circulo es: ${area}cm^2`);

    console.groupEnd();

}

Cuadrado(5);
Triangulo(4,5,6,8);
Circulo(5);

Ésta es mi versión del programa. Espero les guste 😃

Captura de cómo se ve en el navegador:

Código:

const reducer = (accumulator, currentValue) => accumulator + currentValue;

function calculatePerimeterAndSurface(poligon) {
    let area; let data; let perimeter;
    switch (poligon){
        case 1:
            data = prompt(`Write the base and the height, separated by commas:`)
            perimeter = gatherData(data).reduce(reducer) * 2
            area = gatherData(data)[0] * gatherData(data)[1]
            break;
        case 2:
            data = prompt(`Introduce the length of all three sides, separated by commas`)
            perimeter = gatherData(data).reduce(reducer)
            area = heron(data)
            break;
        case 3:
            data = prompt(`Introduce the radius of your circle`)
            perimeter = 2*gatherData(data).reduce(reducer)*Math.PI
            area = Math.PI * data**2
            break;
        case 4:
            data = prompt('All sides are equal: Put here the value of one of them sides')
            sides = prompt(`How many sides has your poligon got?`)
            perimeter = sides * gatherData(data).reduce(reducer)
            area = `Yet not computable by this program`
            break;
    }
    const result = `The perimeter is ${perimeter}cm, whereas the area is ${area}cm squared`
    return result
}

function gatherData(str) {
    let sides = []
    for (let i = 0; i < str.length; i++) {
        const element = str.charAt(i)
        if (parseInt(element)){
            sides.push(parseInt(element))
        }
    }
    return sides
}

function heron (data) {
    let perimeter = gatherData(data).reduce(reducer)
    let sides = gatherData(data)
    let s = perimeter / 2
    return ((s-sides[0])*(s-sides[1])*(s-sides[2]))**1/2
}

Estaré eternamente agradecido si me dan algún consejo! Gracias

Mi codigo0 para el ejecicio recibiendo los valores y utilizando funciones de flecha:

// Cuadrado

const ladoCuadrado = parseInt(prompt('Digite el valor de un lado del cuadrado'));

const perimetroCuadrado = ( l ) => perimetro = l * 4;
const areaCuadrado = ( l ) => area = l * l;

console.group("Cuadrado");

console.log(`La medida de los lados del cuadrado es: ${ladoCuadrado} cm`);
console.log(`El perimetro del cuadrado es: ${perimetroCuadrado(ladoCuadrado)} cm`);
console.log(`El area del cuadrado es: ${areaCuadrado(ladoCuadrado)} cm^2`);

console.groupEnd();


// Triangulo

const ladoTriangulo = parseInt(prompt('Digite el valor del primer lado del triangulo'));
const ladoTriangulo2 = parseInt(prompt('Digite el valor del segundo lado del triangulo'));
const baseTriangulo = parseInt(prompt('Digite el valor de la base del trinagulo'));
const alturaTriangulo = parseInt(prompt('Digite el valor de la altura del triangulo'));

const perimetroTriangulo = ( l, l2, b ) => l + l2 + b;
const areaTriangulo = ( b, a ) => (b*a) /2;

console.group('Triangulo');

console.log(`La medida de los lados del triangulo son: ${ladoTriangulo} cm, ${ladoTriangulo2} cm y el valor de la base es: ${baseTriangulo} cm, el valor de la altura del triangulo es: ${alturaTriangulo} cm`);
console.log(`El perimetro del triangulo es: ${perimetroTriangulo(ladoTriangulo, ladoTriangulo2, baseTriangulo)} cm`);
console.log(`El area del triangulo es de: ${areaTriangulo(baseTriangulo, alturaTriangulo)} cm`);

console.groupEnd();

// Circulo

const radioCirculo = parseInt(prompt('Ingresar el radio del circulo'));
const PI = Math.PI;

const perimetroCirculo = (r, PI) => (r*2) * PI;
const areaCirculo = (r, PI) => (r*r)*PI;

console.group('Circulo');

console.log(`El perimetro del circulo es: ${perimetroCirculo(radioCirculo, PI)}`);
console.log(`El area del circulo es: ${areaCirculo(radioCirculo, PI)}`);

console.groupEnd();

Esta clase cuando comenzó no me gusto pero no se porque fui cambiando de parecer y me parece un 3xcelente ejercicio.

Buen dia champions… Ok, con arrow function ahorramos lineas de codigo en ves de funcones declaritvas, que por cierto cuando se hace un llamado de una function dentro de una function si es necesario usar function declarativa.

console.log("Enscapsulando codigo en funciones")

console.group("Squares")
 const perimeterOfTheSquare = (side) => side * 4
const squareArea = (side) => side * side
console.groupEnd() 
console.group("Triangles");
const perimeterOfTheTriangle = (side1, side2, base) => side1 + side2 + base;
const triangleArea = (base, height) => (base * height)/2
console.groupEnd();
console.group("Circle or circumference, is the same");
//Diameter
const circleDiameter = (radius) => radius * 2
//Pi
const PI = Math.PI;
//Circumference
//Llamara funciones dentro de funciones ... function declarativa
const circlePerimeter = (radius) => {
  const diameter = circleDiameter(radius)
  return diameter * PI
}
//Area
const circleArea = (radius) => (radius * radius) * PI
console.log("\n")
console.groupEnd()
  • Código clase:
<
// Código del cuadrado
console.group("Cuadrados");
// const ladoCuadrado = 5;
// console.log("Los lados del cuadrado miden: " + ladoCuadrado + "cm");

function perimetroCuadrado(lado) {
    return lado * 4;
}
// console.log("El  perimetro del cuadrado es: " + perimetroCuadrado + "cm");

function areaCuadrado(lado) {
    return lado * lado;
}
//console.log("El área del cuadrado es: " + areaCuadrado + "cm^2");

console.groupEnd();

//Códgo del triangulo
console.group("Triangulos")
// const ladoTriangulo1 = 6;

// const ladoTriangulo2 = 6;

// const baseTriangulo = 4;


// console.log(
//     "Los lados del triangulo miden: " 
//     + ladoTriangulo1 
//     + "cm, " 
//     + ladoTriangulo2 
//     +"cm, " 
//     + baseTriangulo 
//     + "cm"
//     );

// const alturaTriangulo= 5.5;
//     console.log("La altura del triángulo es de: " + alturaTriangulo);

function perimetroTriangulo(lado1, lado2, base) {
    return lado1 + lado2 + base;
}
//console.log("El perimetro del triángulo es: " + perimetroTriangulo + "cm")

function areaTriangulo(base, altura) {
    return (base * altura) / 2 ;
}
// const areaTriangulo = (baseTriangulo * alturaTriangulo) / 2;
    //console.log("El área del triángulo es: " + areaTriangulo + "cm^2");

    console.groupEnd();


//Códgo del triangulo
console.group("Círculos");

// Radio
//const radioCirculo = 4;
    //console.log("El radio del circulo es: " + radioCirculo + "cm");

// Diámetro
function diametroCirculo(radio) {
    return radio * 2;
}
//const diametroCirculo= radioCirculo * 2;
    //console.log("El diámetro del circulo es: " + diametroCirculo + "cm");

// Pi
//const PI = 3.1415;
const PI = Math.PI;
    console.log("PI es: " + PI);

// Circunferencia -función dentro de una función
function perimetroCirculo(radio) {
    const diametro = diametroCirculo(radio);
    return diametro * PI;
}
//const perimetroCirculo = diametroCirculo * PI;
    //console.log("El perímetro del círculo es: " + perimetroCirculo + "cm");

// Área
//const areaCirculo = (diametroCirculo * radioCirculo) * PI;
function areaCirculo(radio) {
    return (radio * radio) * PI;
}    
//console.log("El área del círculo es: " + areaCirculo + "cm^2");

console.groupEnd();
> 

Yo lo hice la clase pasada en funciones, solo que cree una función por figura. Será mejor separarlo en funciones por cada una de las operaciones como se realizo en la clase?

Vuelvo a dejar mi código 😃

//Cuadrado
function cuadrado(ladoCuadrado){
    let perimetroC = ladoCuadrado + ladoCuadrado + ladoCuadrado + ladoCuadrado;
    let areaC = ladoCuadrado * ladoCuadrado;
    console.group("Cuadrado");
    console.log(`El perímetro del cuadrado es: ${perimetroC}cm`);
    console.log(`El área del cuadrado es: ${areaC}cm^2`);
    console.groupEnd();
}

cuadrado(156);


//Triangulo
function trinagulo(lado1, lado2, base, altura){
    let perimetroT = lado1 + lado2 + base;
    let areaT = (base * altura) / 2;

    console.group("Triangulo");
    console.log(`El perímetro del triangulo es: ${perimetroT}cm`)
    console.log(`El área del triangulo es: ${areaT}cm^2`)
    console.groupEnd();
}

trinagulo(6, 6, 4, 5.5);


//Circulo
function circulo(radio){
    let diametroCi = radio*2;
    const PI = Math.PI;
    let perimetroCi = diametroCi * PI;
    let areaCi = PI * Math.pow(radio,2);

    console.group("Circulo");
    console.log(`El perímetro del circulo es: ${perimetroCi}cm`);
    console.log(`El área del circulo es: ${areaCi}cm^2`);
    console.groupEnd();
}

circulo(4);

Resultado

// codigo del cuadrado

console.group(“cuadrado”);

// console.log("Los lados del cuadrado miden: " + ladoCuadrado + “cm”);

function perimetroCuadrado(lado){
return lado * 4;
}

// console.log("El perimetro del cuadrados es: " + perimetroCuadrado + “cm”);

function areaCuadrado(lado) {
return lado * lado;
}

//console.log("El Area del cuadrados es: " + areaCuadrado + “cm cuadrados”);

console.groupEnd();

// codigo del triangulo

console.group(“triangulos”)

//const ladoTriangulo1 = 6;
//const ladoTriangulo2 = 6;
//const baseTriangulo = 4;
//const alturaTriangulo = 5.5;

// console.log("Los lados del triangulo miden: "
// + ladoTriangulo1
// + “cm” + ", "
// + ladoTriangulo2
// + “cm”
// + baseTriangulo
// + “cm”
// );

//console.log("La altura del triangulo: "
//+ alturaTriangulo
//+ “cm”
//);

function perimetroTriangulo(lado1, lado2, base) {
return lado1 + lado2 + base;
}

// console.log("El perimetro del triangulo es: " + perimetroTriangulo + “cm”);

function areaTriangulo(base, altura) {
return (base * altura)/2;
}

// console.log("El Area del triangulo es: " + areaTriangulo + “cm cuadrados”);

console.groupEnd();

// codigo del circunferencia

console.group(“circunferencia”)

//const radio = 4;

//console.log("El radio del triangulo mide: "
//+ radio
//+ “cm”
//);

function perimetroCircunferencia(radio) {
const PI = Math.PI;
const diametro = radio * 2;
return diametro * PI;
}

//console.log("El perimetro de la circunferencia es: " + perimetroCircunferencia + “cm”);

function areaCircunferencia(radio){
const PI = Math.PI;
return (radio * radio) * PI;
}

//console.log("El Area de la circunferencia es: " + areaCircunferencia + “cm cuadrados”);

console.groupEnd();

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Figuras geometricas</title>
</head>
<body>
    <header>
        <h1>Figuras geometricas.</h1>
    </header>
    <section>
        <h2>calcula el area de un cuadrado</h2>
        <form action="">
            <label for="inputCuadrado">Escribe el lado de tu cuadrado </label>
            <input id="inputCuadrado" type="number">
            <button type="button" onclick="calcularPerimetroCuadrado()">calcula el perimetro </button>
            <button type="button" onclick="calcularAreaCuadrado()">calcula el area </button>
        </form>
        <form action="">
            <label for="inputTriangulo1">Escribe el lado 1 de tu triangulo</label>
            <input id="inputTriangulo1" type="number">
            <label for="inputTriangulo2">Escribe el lado 2 de tu triangulo</label>
            <input id="inputTriangulo2" type="number">
            <label for="inputTriangulo3">Escribe la base de tu triangulo</label>
            <input id="inputTriangulo3" type="number">
            <label for="inputTriangulo4">Escribe la altura de tu triangulo</label>
            <input id="inputTriangulo4" type="number">
            <button type="button" onclick="calcularPerimetroTriangulo()">calcula el perimetro </button>
            <button type="button" onclick="calcularAreaTriangulo()">calcula el area </button>
        </form>
        <form action="">
            <label for="inputCirculo">Escribe el radio de tu circulo. </label>
            <input id="inputCirculo" type="number">
            <button type="button" onclick="calcularDiametroCirculo()">calcula el circulo </button>
            <button type="button" onclick="calcularPerimetroCirculo()">calcula el perimetro </button>
            <button type="button" onclick="calcularAreaCirculo()">calcula el area </button>
        </form>
    </section>
    <script src="./figuras.js"></script>
</body>
</html>

//JS

/* console.group("title");    Agrupa todos los console.log(""); hasta el proximo console.groupEnd();
console.groupEnd(); */

// Cuadrado

/* const ladoCuadrado = 5;
const perimetroCuadrado = ladoCuadrado * 4;
const areaCuadrado = ladoCuadrado * ladoCuadrado; */

function perimetroCuadrado(lado){
    return lado * 4;
}
function areaCuadrado(lado){
    return lado * lado;
}

// Triangulo

/* const ladoTriangulo1 = 6;
const ladoTriangulo2 = 6;
const baseTriangulo = 4;
const alturaTriangulo = 5.5;
const perimetroTriangulo = ladoRectangulo1 + ladoRectangulo2 + baseTriangulo;
const areaTriangulo = (baseTriangulo * alturaTriangulo) / 2; */

function perimetroTriangulo(lado1, lado2, base){
    return parseInt(lado1) + parseInt(lado2) + parseInt(base);
}
function areaTriangulo(base, altura){
    return (base * altura) / 2;
}

//cirulo

/* const radioCirculo = 4;
const diametroCirculo = radioCirculo * 2;
const pi = Math.PI;
const perimetroCirculo = diametroCirculo * pi;
const areaCirculo = (radioCirculo * radioCirculo) * pi; */

const pi = Math.PI;
function diametroCirculo(radio){
    return radio * 2;
}
function perimetroCirculo(radio){
    const diametro = diametroCirculo(radio);
    return diametro * pi;
}
function areaCirculo(radio){
    return (radio * radio) * pi;
}

//HTML

//cuadrado
function calcularPerimetroCuadrado(){
    const input = document.getElementById("inputCuadrado");
    const value = input.value;
    const perimetro = perimetroCuadrado(value);
    alert(perimetro);
}
function calcularAreaCuadrado(){
    const input = document.getElementById("inputCuadrado");
    const value = input.value;
    const area = areaCuadrado(value);
    alert(area);
}

//triangulo
function calcularPerimetroTriangulo(){
    const input1 = document.getElementById("inputTriangulo1");
    const input2 = document.getElementById("inputTriangulo2");
    const input3 = document.getElementById("inputTriangulo3");
    const lado1 = input1.value;
    const lado2 = input2.value;
    const base = input3.value;
    const perimetro = perimetroTriangulo(lado1, lado2, base);
    alert(perimetro);
}

function calcularAreaTriangulo(){
    const input1 = document.getElementById("inputTriangulo3");
    const input2 = document.getElementById("inputTriangulo4");
    const base = input1.value;
    const altura = input2.value;
    const area = areaTriangulo(base, altura);
    alert(area);
}

//Circulo
function calcularDiametroCirculo(){
    const input = document.getElementById("inputCirculo");
    const radio = input.value;
    const diametro = diametroCirculo(radio);
    alert(diametro);
}

function calcularPerimetroCirculo(){
    const input = document.getElementById("inputCirculo");
    const radio = input.value;
    const perimetro = perimetroCirculo(radio);
    alert(perimetro);
}

function calcularAreaCirculo(){
    const input = document.getElementById("inputCirculo");
    const radio = input.value;
    const area = areaCirculo(radio);
    alert(area);
}

// Codigo del cuadrado
console.group(“Cuadrado”);
// const ladoCuadrado = 5;
// console.log(“Los lados del cuadrado:” + ladoCuadrado + " cm cuadrados");

function perimertroCuadrado(ladoCuadrado) {
return ladoCuadrado * 4;
}
// perimertroCuadrado(lado);

// console.log(“El perimetro del cuadrado es:” + perimertroCuadrado + " cm cuadrados");
function areaCuadrado(lado) {
return (lado * lado);
}
console.log(“El Area del cuadrado:” + areaCuadrado + " cm cuadrados");
console.groupEnd();

// Codigo del triangulo
console.group(“Triangulo”);
// const ladoTriangulo1 = 6;
// const ladoTriangulo2 = 6;
// const baseTriangulo = 4;
// const alturaTriangulo = 5.5;
// console.log(“los lados de mi triangulo miden :” +
// ladoTriangulo1 + " cm, " + ladoTriangulo2 + " cm y la base" + baseTriangulo);
// console.log(“la altura del triangulo:” + alturaTriangulo + " cm");
function perimetroTriangulo(ladoTriangulo1, ladoTriangulo2, baseTriangulo) {
return ladoTriangulo1 + ladoTriangulo2 + baseTriangulo;
}
// const perimetroTriangulo = ladoTriangulo1 + ladoTriangulo2 + baseTriangulo;
// console.log(“El perimetro del triangulo:” + perimetroTriangulo + " cm");
function areaTriangulo(baseTriangulo, alturaTriangulo) {
return (baseTriangulo * alturaTriangulo) / 2;
}
// const areaTriangulo = (baseTriangulo * alturaTriangulo) / 2;
// console.log(“El area del triangulo:” + areaTriangulo + " cm");
console.groupEnd();

// Codigo del circulo
console.group(“Circulo”);
// Radio
// const radioCirculo = 4;
// console.log(“el radio del circulo es:” + radioCirculo);
// Diametro
function diametroCiruclo(radioCirculo) {
return radioCirculo * 2;
}
// const diametroCiruclo = radioCirculo * 2;
// console.log(“el diametro del circulo es:” + diametroCiruclo);
// circunferencia
// pi
// const PI = 3.1415;
const PI = Math.PI;

function perimetroCirculo(radioCirculo) {
const diametro = diametroCiruclo(radioCirculo);
return diametro * PI;
}

function areaCiculo(radioCirculo) {
return (radioCirculo * radioCirculo) * PI;
}
// const perimetroCirculo = diametroCiruclo * PI
// console.log(“el perimetro del circulo es:” + perimetroCirculo);
// area
// const areaCiculo = (radioCirculo * radioCirculo) * PI;
// console.log(“el area del circulo es:” + areaCiculo);
console.groupEnd();

Hola dejo mi resultado de la practica:

// Código del Cuadrado

console.group('Cuadrado');

const ladoCuadrado = parseFloat(prompt('Ingrese el lado'));
console.log('Los lados del cuadrado miden: ' + ladoCuadrado + 'cm');

function perimetroCuadrado(lado) {
    return lado * 4
}
console.log('El perímetro del cuadrado es: ' + perimetroCuadrado(ladoCuadrado) + 'cm');

function areaCuadrado(lado) {
    return lado * lado;

}
console.log('El área del cuadrado es: ' + areaCuadrado(ladoCuadrado) + 'cm^2');

console.groupEnd();

// Código del Triángulo

console.group('Triángulo');

const triangulo = {
    lado1: parseFloat(prompt('Ingrese el lado 1')),
    lado2: parseFloat(prompt('Ingrese el lado 2')),
    base: parseFloat(prompt('Ingrese la base')),
    altura: parseFloat(prompt('Ingrese la altura'))
};
console.log('La altura del triángulo mide: ' + triangulo.altura + 'cm');
console.log('Los lados del triángulo miden: ' + triangulo.lado1 + 'cm,' + triangulo.lado2 + 'cm,' + triangulo.base + 'cm');

const perimetroTriangulo = (triangulo) => triangulo.lado1 + triangulo.lado2 + triangulo.base;
console.log('El perímetro del triángulo es: ' + perimetroTriangulo(triangulo) + 'cm');

const areaTriangulo = (triangulo) =>  (triangulo.base * triangulo.altura) / 2;
console.log('El área del triángulo es: ' + areaTriangulo(triangulo) + 'cm^2');

console.groupEnd();


// Código del Círculo
console.group('Círculo');

const radioCirculo = parseFloat(prompt('Ingrese el radio'));
console.log('El radio del Círculo es: ' + radioCirculo + 'cm');

const diametroCirculo =  (radio) => radio * 2;
console.log('El diametro del Círculo es: ' + diametroCirculo(radioCirculo) + 'cm');

const PI = Math.PI;
console.log('El valor de PI es: ' + PI);

const perimetroCirculo = (diametro, pi) => diametro * pi;
console.log('El perímetro del Círculo es: ' + perimetroCirculo(diametroCirculo(radioCirculo),PI) + 'cm');

const areaCirculo = (radio, pi) => (radio * radio) * pi;
console.log('El área del Círculo es: ' + areaCirculo(radioCirculo, PI) + 'cm^2');

console.groupEnd();

Para poder imprimir el retorno de las funciones en un console.log, se hace de la siguiente manera:

//condigo de los cuadrados. 
console.group('Cuadrados');
const ladoCuadrado1 = 5;

function perimetroCuadrado(lado) {
    return lado * 4;
}
function areaCuadrado(lado) {
    return lado**2;
}

console.log(`los lados del cuadrado miden: ${ladoCuadrado1}`);
console.log(`El perimetro del cuadrado es: ${perimetroCuadrado(ladoCuadrado1)}`);
console.log(`El area del cuadrado es: ${areaCuadrado(ladoCuadrado1)}`);
console.groupEnd();
const getSquarePerimeter = (side) => side * 4;
const getSqueareArea = (side) => side * side;

const getTrianglePerimeter = (side1, side2, base) => side1 + side2 + base;
const getTriangleArea = (base, height) => (base * height) / 2;

const getCircleDiameter = (radio) => radio * 2;
const getCirclePerimeter = (radio) => getCircleDiameter(radio) * Math.PI;
const getCircleArea = (radio) => radio * radio * PI;

Excelente explicación de las funciones en JavaScript.

Podemos utilizar las arrow fuction para ahorrar nuestras líneas de codigo y mejorar el codigo en si 👍

const  perimetroCuadrado = lado => lado *4 ;

Mi código lo hice con arrow functions y al altura se calcula automáticamente usando teorema de Pitágoras. Esto lo vi en el aporte de un compañero en la clase anterior.

//Cuadrado
const perimetroCuadrado = lado => lado * 4;
const areaCuadrado = lado => lado **2;

 //Triángulo 
 console.group("Triángulo")

 const perimetroTriangulo = (lado1, lado2, base) => lado1 + lado2 + base; 
 const areaTriangulo = (lado1, lado2, base) => {
    const altura = Math.sqrt((base / 2) **2 + lado1 **2).toFixed(2)
    let area = base * altura / 2;
    return area;
}
console.groupEnd();
//Circulo 
 console.group("Circulo")
 const PI = Math.PI;

 const perimetroCirculo = radio => PI * (radio * 2);
 const areaCirculo = radio => PI * (radio **2);
 console.groupEnd(); 

Funciones era algo que no me quedaba muy claro, pero esta clase enderezó mi camino, al igual que: PARAMETROS: Declarar la function dentro de ()
ARGUMENTOS: Cuando llamamos a ejecutarla.
Excelente clase!!

Para comentar lineas:
Ctrl+K Ctrl+C

const squareSide = 5;
const squarePerimeter = (side) => side * 4;
const squareArea = side => side * side;

console.group('Square');
console.log(`square side: ${squareSide}cm`);
console.log(`the perimeter is: ${squarePerimeter(squareSide)}cm`);
console.log(`the square area is: ${squareArea(squareSide)}cm^2`)
console.groupEnd()

const triangleSideA = 6;
const triangleSideB =6;
const triangleBase = 4;

const triangleHeight = base => Math.sqrt((base/2) ** 2 + 6 ** 2);
// Como se puede dejar sin parentesis, pero únicamente cuando es solo un argumento.
// Se puede dejar con parentesis cuando pasamos valores en las  arrow function
const trianglePerimeter = (sideA,sideB,base) => sideA + sideB + base;
const triangleArea = (base, height) => (1/2) * base * height;

console.group('Triangle');
console.log(`Triangle sides: 
  A:${triangleSideA}cm,
  B:${triangleSideB}cm,
  C:${triangleBase}cm`);
console.log(`Triangle Perimeter: 
  ${trianglePerimeter(triangleSideA, triangleSideB, triangleBase)}cm`);
console.log(`Triangle Area: 
  ${triangleArea(triangleBase,triangleHeight)}cm^2`);
console.groupEnd();

const PI = Math.PI;
const circleRadio = 1;
const circleDiameter = radio => 2 * radio;
const circleCircumference = diameter => diameter * PI;
const circleArea = radio => (radio * radio) * PI;

console.group('Circle');
console.log(`Circle radio: ${circleRadio}cm`);
console.log(`Circle Diameter: ${circleDiameter(circleRadio)}cm`);
console.log(`Circle Circumference: ${circleCircumference(circleDiameter)}cm`);
console.log(`Circle Area: ${circleArea(circleRadio)}cm^2`);
console.groupEnd();

chale, hice spoiler por accidente con mi aporte en la clase pasada 😦

Les dejo mi código usando arrow functions 😃

// Constants
const { PI } = Math;

// Functions
const perimeterSquare = (l) => l * 4;

const areaSquare = (l) => l * l;

const perimeterTriangule = (lOne, lTwo, b) => lOne + lTwo + b;

const areaTriangle = (b, h) => (b * h) / 2;

const circuleDiameter = (r) => r * 2;

const calculatePerimeterSquare = () => {
  // eslint-disable-next-line no-alert
  alert(perimeterSquare(document.getElementById('InputCuadrado').value));
};

const calculateSquareArea = () => {
  // eslint-disable-next-line no-alert
  alert(areaSquare(document.getElementById('InputCuadrado').value));
};

const perimeterCircule = (r) => circuleDiameter(r) * PI;

const areaCircule = (r) => r * r * PI;

Una propuesta muy interesante es aprovechar el paradigma de la programación orientada a objetos, de esta forma podemos crear una clase llamada Cuadrado y a esta le vamos agregando los métodos, como el método perimetro y area.

Por ejemplo cada vez que quisiéramos saber el perímetro o el area de un cuadrado lo haríamos con algo como esto:

Cuadrado.perimetro(5) 
Cuadrado.area(5) 

Así comencé a editar el codigo

//CODIGO DEL CUADRADO

console.group("CODIGO DEL CUADRADO")   //Esto sirve para hacer grupos de codigo

const ladoCuadrado = 5
console.log(`Los lados del cuadrado miden ${ladoCuadrado}`)

const calcPerimetroCuadrado = lado => lado*4
const calcAreaCuadrado = lado => lado**2
console.log(`El perimetro del cuadrado es de: ${calcPerimetroCuadrado(ladoCuadrado)}cm,
y su area es de: ${calcAreaCuadrado(ladoCuadrado)}cm^2`)

console.groupEnd()

//CODIGO DEL TRIANGULO

console.group("CODIGO DEL TRIANGULO")

const ladoTriangulo1 = 6
const ladoTriangulo2 = 6
const baseTraingulo = 4
const alturaTriangulo = 5.5 

const calcPerimetroTriangulo = (lado1, lado2, base) => lado1 + lado2 + base
const calcAreaTriangulo = (base, altura) => (base*altura)/2
console.log(`El perimetro del triangulo es de: ${calcPerimetroTriangulo(ladoTriangulo1, ladoTriangulo2, baseTraingulo)}cm,
y su area es de: ${calcAreaTriangulo(baseTraingulo, alturaTriangulo)}cm^2`)

console.groupEnd()

//CODIGO CIRCULO

console.group("CODIGO DEL CIRCULO")

const radio = 4
const pi = Math.PI

const calcPerimetroCirculo = (radio, pi) => (2 * pi * radio).toFixed(2)
const calcAreaCirculo = (radio, pi) => (pi*(radio**2)).toFixed(2)
console.log(`El perimetro del circulo es de: ${calcPerimetroCirculo(radio, pi)}cm,
y su area es de: ${calcAreaCirculo(radio, pi)}cm^2`)

console.groupEnd()
// Square
const perimeterSquare = (sideSquare) => {
  return sideSquare * 4;
}
const areaSquare = (sideSquare) => {
  return sideSquare ** 2;
}
// Triangle

const trianglePerimeter = (sideA, sideB, base) => {
  return sideA + sideB + base;
}

const triangleArea = (base, height) => {
  return (base * height) / 2;
}

// Circle
const circleDiameter = (radius) => {
  return radius * 2;
}
const circlePerimeter = (radius) => {
  const diameter = circleDiameter(radius);
  return diameter * Math.PI;
}

const circleArea = (radius) => {
  return radius * radius * Math.PI;
}

// Codigo del cuadrado

console.group("Cuadrados");

const perimeterSquare = (lado) => {
    return lado * 4;
}

const areaSquare = (lado) => {
    return lado * lado;
}

console.groupEnd();

// Codigo del triangulo

console.group("Triangulos");

const perimeterTriangle = (lado1, lado2, base) => {
    return lado1 + lado2 + base;
}

const areaTriangle = (base, altura) =>{
    return (base * altura)/2;
}


console.groupEnd();

// Codigo del circulo 

console.group("Circle");

const PI = Math.PI; 

const diameterCircle = (radio) => radio * 2;

const perimeterCircle = (radio) => diameterCircle(radio) * PI;

const areaCircle = (radio) => radio * radio * PI; 


console.groupEnd();

Usando Arrow Functions

//Cuadrado
const perimetroCuadrado = (lado) => lado * 4;

const areaCuadrado = (lado) => Math.pow(lado, 2);

//Triangulo

const perimetroTriangulo = (lado1, lado2, base) => lado1 + lado2 + base;

const areaTriangulo = (base, altura) => (base * altura) / 2;

//Circulo

const diametroCirculo = (radio) => radio * 2;

const PI = Math.PI;

const perimetroCirculo = (radio) => diametroCirculo(radio) * PI;

const areaCirculo = (radio) => Math.pow(radio, 2) * PI;

Yo les vengo manejando lo que viene siendo el uso de objetos. Lo implemente con POO para hacerlo más atómico y escalable.

const createSquare = (sideLength) => ({
    side : sideLength,
    getPerimeter(){return this.side*4},
    getArea(){return this.side**2},
})

const createTriangle = (baseLength, height, sideOneLength, sideTwoLength) => ({
    base :baseLength,
    height: height,
    'side-1':sideOneLength,
    'side-2': sideTwoLength,
    getPerimeter(){return (this.base + this["side-1"] + this["side-2"])},
    getArea(){return (this.base*this.height)/2},
}) 

const createCircle = (radius) => ({
    radius: radius,
    PI: Math.PI,
    diameter: this.radius*2,
    getPerimeter(){return this.diameter*this.PI},
    getArea(){return (this.PI*this.radius**2)},
})

// Create the Figures
const circle = createCircle(5);
const triangle = createTriangle(5,5,5,5);

// Print in Console

// Circle
console.group('Circle');
console.table(circle);
console.table(circle.getArea());
console.groupEnd();

// Triangle
console.group('Triangle');
console.table(triangle);
console.log(triangle.getArea());
console.log(triangle.getPerimeter());
console.groupEnd();

// encapsulando en funciones
// cuadrado
const perimetCuadrado = (lado) => lado * 4
const areCuadrado = (lado) => lado**2

// Trigangulo
const perimetTriangulo = (lado1, lado2, base) => lado1 + lado2 + base
const areTriangulo = (base, altura) => (base * altura)/2

// Circunference
const perimetCirculo = (radio) => {
const PI = Math.PI
let diametro = radio * 2
return diametro * Pi
}

const areCirculo = (radio) => {
const PI = Math.PI
return radio**2 * PI
}

Para redondear podemos hacerlo de la siguiente forma:

function circunferenciaCirculo (radio){
    return Math.round((Math.PI * diametroCirculo(radio))*100)/100;
}

function areaCirculo (radio){
    return Math.round((Math.PI * (radio * radio)*100))/100;
}

Excelente clase y su explicación es bien detallada.

Anterior

function perimetroCirculo (radio) {
    const diametro = diametroCirculo(radio);
    return diametro * PI;
}

Sería lo mismo escribir la función de “perimetroCirculo()” de esta manera ¿no?

function perimetroCirculo (radio) {
    return diametroCirculo(radio) * PI;
}

Mis funciones de la clase, uso el semiperimetro del triangulo para calcular el área y mostrar la altura.

//Código del cuadrado
const perimetroCuadrado = (ladoCuadrado) => ladoCuadrado * 4;
const areaCuadrado = (ladoCuadrado) => ladoCuadrado * ladoCuadrado;

//Código del triangulo
const perimetroTriangulo = (lado1Triangulo, lado2Triangulo, baseTriangulo) => lado1Triangulo + lado2Triangulo + baseTriangulo;
const areaTriangulo = (lado1Triangulo, lado2Triangulo, baseTriangulo) => {
    let semiPerimetro = (lado1Triangulo + lado2Triangulo + baseTriangulo)/2;
    return Math.sqrt(semiPerimetro * (semiPerimetro-lado1Triangulo) * (semiPerimetro-lado2Triangulo) * (semiPerimetro-baseTriangulo));
};
const alturaTriangulo = (lado1Triangulo, lado2Triangulo, baseTriangulo) => {
    const area = areaTriangulo(lado1Triangulo, lado2Triangulo, baseTriangulo);
    return (2 * area) / baseTriangulo;
};

//Código del Circulo
const diametroCirculo = (radioCirculo) => radioCirculo*2;
const perimetroCirculo = (radioCirculo) => radioCirculo*2*Math.PI;
const areaCirculo = (radioCirculo) => Math.PI*(radioCirculo)**2;

Dejo mi codigo con sus console.log en grupos

const cuadrado = (lado) =>  {
  console.group("Cuadrado");
  console.log(`Perimetro: ${lado * 4}`);
  console.log(`Area: ${lado ** 2}`);
  console.groupEnd();
}

const triangulo = (base, altura, lado) => {
  console.group("Triangulo");
  console.log(`Perimetro: ${(base+(lado*2))}`);
  console.log(`Area: ${(base*altura)/2}`);
  console.groupEnd();
}

const circulo = (radio) => {
  const PI = Math.PI;
  console.group("Circulo");
  console.log(`Perimetro: ${(2*PI)*radio}`)
  console.log(`Area: ${PI*(radio**2)}`)
    console.groupEnd();

}


Código

//Codigo del Cuadrado

console.group("cuadrados");

perimetroCuadrado = (lado) => {
    return lado * 4;
}
perimetroCuadrado();

areaCuadrado = (lado) => {
    return lado * lado;
}
areaCuadrado();
console.groupEnd();



//Codigo del Triàngulo

console.group("triangulos");


    perimetroTriangulo = (lado1, lado2, base) => {
        return lado1 + lado2 + base;
    }
    perimetroTriangulo();
    

    areaTriangulo = (base, altura) => {
        return (base * altura) / 2;
    }

    console.groupEnd();



    //Codigo del Cìrculo

console.group("Cìrculos");

// Diàmetro
diametroCirculo = (radio) => {
    return radio * 2;
}
diametroCirculo();


// PI
const PI = Math.PI;
console.log ("El PI es: " + PI + "cm");


// Circuferencia
perimetroCirculo = (radio) => {
    const diametro = diametroCirculo(radio);
    return diametro * PI;
}
perimetroCirculo();


// Àrea
areaCirculo = (radio) => {
    return (radio * radio) * PI;
}
areaCirculo();


console.groupEnd();

Excelente explicación de funciones.

Atajo para borrar líneas con estilo en VSCode: Ctril+Shift+K
Saludos 😀

uuuuf por fin entendi al 100% funciones… gracias prof. Juan David Castro

para la gente que se pregunta como comentar con el teclado en linux seria:

CTRL] + K (Vscode queda a la espera). Después pulsa [CTRL] + C para comentar y [CTRL] + U para descomentar.

Para seleccionar con el teclado podemos usar la combinación control más llave que cierra

** Ctrl + } **

Funciona con el teclado en español

function perimetroCuadrado(lado) {
return lado * 4;
}

function areaCuadrado(lado) {
return lado * lado;
}

function areaTriangulo(base, altura) {
return base * altura / 2;
}

function circunferenciaCirculo(radio) {
return 2 * Math.PI * radio;
}

Para macOS si quieres seccionar y comenar un bloque de código solo debes:
Seleccionar el bloque a comentar.
cmd+ K (y sin soltar la tecla Ctrl) + C
Saludos

//Codigo del CUADRADO

function perimetroCuadrado(ladoCuadrado){
    return ladoCuadrado * 4;
}
perimetroCuadrado(5);


function areaCuadrado(ladoCuadrado){
    return ladoCuadrado * ladoCuadrado;
}
areaCuadrado(12);

//Codigo del TRIANGULO

function perimetroTriangulo(ladoTriangulo1,ladoTriangulo2,baseTriangulo){
    return ladoTriangulo1 + ladoTriangulo2 + baseTriangulo;
}
perimetroTriangulo(6,6,4);

function areaTriangulo(baseTriangulo, alturaTriangulo){
    return (baseTriangulo * alturaTriangulo) / 2;
}
areaTriangulo(4,5);


//Codigo del CIRCULOS

function perimetroCirculo(radioCirculo){
    return (radioCirculo * 2) * Math.PI;
}
perimetroCirculo(5);

function areaCirculo(radioCirculo){
    return (radioCirculo * radioCirculo) * Math.PI;
}
areaCirculo(5);

hola, hize algo sencillo suma y multiplicacion con cajas, revisen el codigo

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="./suma.js"></script>
    
</head>
<body>
    <h1> Este es mi Primer Autosave</h1>
    <p>vamos a empezar</p>
    <section>
        <form>
          <label for="InputCuadrado1">
eSCRFIBE ALGO

          </label>
                
        <input id="NumeroUno" type ="number"/>
        <input id="NumeroDos" type ="number"/>
        

        <button type="button" onclick="calcularSuma()"> 
          Calcular suma
        </button>
        
        <button type="button" onclick="calcularMultiplicacion()"> 
          Calcular Multiplicacion
        </button>
        
        </form>



    </section>
    
    
    <script src="./suma.js"></script>
</body>
</html>

CSS

function suma(lado1,lado2){
    return parseInt(lado1+lado2);
}
function multi(lado1,lado2){
    return parseInt(lado1*lado2);
}

function calcularSuma(){
    var numero1 =parseInt(document.getElementById("NumeroUno").value);
    var numero2=parseInt(document.getElementById("NumeroDos").value);


    var calculo=suma(numero1,numero2);
    alert(calculo);
    console.log(calculo);
    document.writeln(calculo);
}

function calcularMultiplicacion(){
    var numero1 =parseInt(document.getElementById("NumeroUno").value);
    var numero2=parseInt(document.getElementById("NumeroDos").value);


    var calculo=multi(numero1,numero2);
    alert(calculo);
    console.log(calculo);
    document.writeln(calculo);
}


Primer función. Cuadrado

Función triangulo

función circulo

pasado de bueno el curso

Para comentar y descomentar el codigo rapido como lo hace el profesor es con:

Windows: [CTRL] + K (Vscode queda a la espera). Después pulsa [CTRL] + C para comentar y [CTRL] + U para descomentar.

MAC: [CMD] + K (Vscode queda a la espera). Después pulsa [CMD] + C para comentar y [CMD] + U para descomentar.

// Codigo del cuadrado
console.group("cuadrado")
const ladoCuadrado = 5;
console.log(`Lados del cuadrado miden ${ladoCuadrado}cm`);

let perimetroCuadrado = () => `El perimetro del cuadrado es: ${(ladoCuadrado * 4)}cm`;
console.log(perimetroCuadrado());

let areaCuadrado2 = () => `El area del cuadrado es: ${(ladoCuadrado * ladoCuadrado)}cm²`;
console.log(areaCuadrado2());
console.groupEnd();

// Codigo del trui
console.group("Triangulos");

function Triangulos(ladoTriangulo1, ladoTriangulo2, baseTriangulo, alturaTriangulo) {
    console.log(`La altura del triangulo es: ${alturaTriangulo}cm`);
    console.log(`La area del triangulo es: ${(baseTriangulo * alturaTriangulo) / 2}cm²`);
    console.log(`El perimetro del triangulo es: ${ladoTriangulo1 + ladoTriangulo2 + baseTriangulo}cm`);
}

Triangulos(6, 6, 6, 5.5)
console.groupEnd();

// Circulo
console.group("Circulo"); 
function circulo(radioCirculo, diametroCirculo, PI) {
    console.log(`El area del circulo es: ${Math.round((PI * Math.pow(radioCirculo, 2)))}cm²`);
    console.log(`El diametro del circulo es: ${Math.round(diametroCirculo * PI)}cm`);
}
circulo(4.5, 6.5, Math.PI);
console.groupEnd();

También puedes usar la función de Math.pow() para hacer operaciones de Potencia al número que le ordenas, los parámetros son la base de la potencia y luego el exponente ejemplo Math.pow(lado, 2) quedaría como función (conste que aún no lo probé en una función)

function areaCuadrado(lado) {
    return Math.pow(lado, 2);
}

y como constante (si funciona)

const areaCuadrado = Math.pow(ladoCuadrado, 2);

y así quedaría más elegante (al menos para mí) el código
saludos, nunca pares de aprender !!

Al llamar a una función desde otra función, no guarde la función a llamar en una variable la utilice directamente y funciono

Los argumentos son los valores que adquiere una función al ser llamada, los parametros es la definición de estos argumentos en una función

para operar un exponente, la manera mas abreviada y facil es poner doble asterisco seguido del valor del exponente.

const areaCirculo= pi * ( radioCirculo ** 2 );

Recomiendo hacer validaciones por si el usuario ingresa numeros negativos

Ejemplo:

function perimetroCuadrado(lado) {
    const perimetro = 0;

    if(lado > 0) {
        perimetro = lado * 4;
    }

    return perimetro;
}

Como perimetro vale 0, si lado es un numero negativo o 0 no se realiza la operacion. Luego podemos ver que mensaje le damos al usuario, en caso de que el retorno de la funcion sea 0 podremos darle un mensaje de error

let resultado = perimetroCuadrado(-5);
if(resultado != 0) {
    console.log("Bien! El resultado es: " + resultado + "cm");
}
else {
    console.log("Error! No es posible calcular el perimetro");
}

Personalmente no disfruto los cursos con este profesor, son demasiados largos y da mucho rodeo de las cosas, termina cansando.

Me dormi como tres veces, seria ideal sin tanto floro.

Aprende Leonidas Esteban, esto si es enseñar

Excelentee, esta vez fue super fácil entender las funciones

Hola Devs, optimice el codigo con comentarios y demas, se que puede ser mas codigo, pero es bueno tener descripciones para entender como funciona:

/**
 * @param {number} squareSide
 * @returns {number}
 * @description Calculate the perimeter of a square
 * @example
 * perimeterSquare(3); // => 12
 */
const squarePerimeter = (squareSide) => squareSide * 4;

/**
 * @param {number} squareSide
 * @returns {number}
 * @description Calculate the area of a square
 * @example
 * areaSquare(3); // => 9
 */
const squareArea = (squareSide) => squareSide * squareSide;

/**
 * @param {number} base
 * @param {number} height
 * @returns {number}
 * @description Calculate the area of a triangle
 * @example
 * areaTriangle(3, 4); // => 6
 */
const areaTriangle = (base, height) => (base * height) / 2;

/**
 * @param {number} sideOne
 * @param {number} sideTwo
 * @param {number} base
 * @returns {number}
 * @description Calculate the perimeter of a triangle
 * @example
 * perimeterTriangle(3, 4, 5); // => 12
 */
const trianglePerimeter = (sideOne, sideTwo, base) => sideOne + sideTwo + base;

const PI = Math.PI;

/**
 * @param {number} radio
 * @returns {number}
 * @description Calculate the diameter of a circle
 * @example
 * diameterCircle(3); // => 6
 */
const diameterCircle = (radio) => radioCircle * 2;

/**
 * @param {number} radio
 * @returns {number}
 * @description Calculate the circumference of a circle
 * @example
 * circumferenceCircle(3); // => 18.84
 */
const circumferenceCircle = (radio) => PI * diameterCircle(radio);

/**
 * @param {number} radio
 * @returns {number}
 * @description Calculate the area of a circle
 * @example
 * areaCircle(3); // => 28.27
 */
const areaCircle = (radio) => PI * (radioCircle * radioCircle);

Les dejo mi codigo, decidi usar clases para englobar todas las funciones para cada forma geométrica:

//Codigo del cuadrado

class Cuadrado {
  constructor(lado) {
    this.lado = lado;
  }

  get getLado() {
    return this.lado;
  }

  get perimetro() {
    return this.calcPerimetro();
  }

  get area() {
    return this.calcArea();
  }

  printLado() {
    return `Los lados miden: ${this.getLado} cm`;
  }

  calcPerimetro() {
    return this.lado * 4;
  }

  perimetroString() {
    return `${this.calcPerimetro()} cm`;
  }

  printPerimetro() {
    return `El perimetro es: ${this.perimetroString()}`;
  }

  calcArea() {
    return this.lado ** 2;
  }

  areaString() {
    return `${this.calcArea()} cm^2`;
  }

  printArea() {
    return `El area es: ${this.areaString()}`;
  }

  printInfo() {
    console.group("Cuadrado");
    console.log(this.printLado());
    console.log(this.printPerimetro());
    console.log(this.printArea());
    console.groupEnd();
  }
}

//Codigo del trinagulo

class Triangulo {
  constructor(lado1, lado2, base) {
    this.lado1 = lado1;
    this.lado2 = lado2;
    this.base = base;
    this.altura = Math.sqrt(this.lado1 ** 2 - (this.base / 2) ** 2).toFixed(2);
  }
  get getLado1() {
    return this.lado1;
  }

  get getLado2() {
    return this.lado2;
  }

  get getBase() {
    return this.base;
  }

  get getAltura() {
    return this.altura;
  }

  printLados() {
    return `Los lados miden: ${this.getLado1} cm y ${this.getLado2} cm`;
  }

  printBaseAltura() {
    return `La base mide: ${this.getBase} cm, y la altura: ${this.getAltura} cm`;
  }

  calcPerimetro() {
    return this.lado1 + this.lado2 + this.base;
  }

  perimetroString() {
    return `${this.calcPerimetro()} cm`;
  }

  printPerimetro() {
    return `El perimetro es: ${this.perimetroString()}`;
  }

  calcArea() {
    return (this.altura * this.base) / 2;
  }

  areaString() {
    return `${this.calcArea()} cm^²`;
  }

  printArea() {
    return `El area es: ${this.areaString()}`;
  }

  printInfo() {
    console.group("Triangulo");
    console.log(this.printLados());
    console.log(this.printBaseAltura());
    console.log(this.printPerimetro());
    console.log(this.printArea());
    console.groupEnd();
  }
}

//Codigo del Circulo
class Circulo {
  constructor(radio) {
    this.radio = radio;
    this.diametro = radio * 2;
  }

  get getRadio() {
    return this.radio;
  }

  get getDiametro() {
    return this.diametro;
  }

  printRadioDiametro() {
    return `Èl radio mide: ${this.getRadio} cm y el diametro: ${this.getDiametro} cm`;
  }

  calcCircunferencia() {
    return this.diametro * Math.PI;
  }

  circunferenciaString() {
    return `${this.calcCircunferencia().toFixed(2)} cm`;
  }

  printCircunferencia() {
    return `La circunferencia mide: ${this.circunferenciaString()}`;
  }

  calcArea() {
    return this.radio ** 2 * Math.PI;
  }

  areaString() {
    return `${this.calcArea().toFixed(2)} cm^2`;
  }

  printArea() {
    return `El area mide: ${this.areaString()}`;
  }

  printInfo() {
    console.group("Circulo");
    console.log(this.printRadioDiametro());
    console.log(this.printCircunferencia());
    console.log(this.printArea());
    console.groupEnd();
  }
}

let miCuadrado = new Cuadrado(4);

miCuadrado.printInfo();

let miTriangulo = new Triangulo(6, 6, 4);

miTriangulo.printInfo();



let miCirculo = new Circulo(4);

miCirculo.printInfo();

P.D: No use las mejores practicas en mi codigo, repeti codigo en varios lados.

Ejemplo usando funciones flecha y parámetros por defecto.

// Código Círculo
console.group("Círculo");
// Perímetro círculo usando arrow function
const perimetroCiruclo = radioCirculo => Math.PI * 2 * radioCirculo;
console.log(`La circunferencia del círculo es: ${perimetroCiruclo(5)} cm`);
// Area cículo usando arrow function con parámetros por defecto
const areaCirculo = (radioCirculo = 5) => (radioCirculo * radioCirculo) * Math.PI  ;
console.log(`El area del círculo es: ${areaCirculo()} cm^2`);
// Fin grupo
console.groupEnd();

Hi people. how are you?
This is my solution

/* Perimetro = P | Area = A */
const unidad = "cm";
/*
  Cuadrado
  A = a^2
  P = a*4
*/
const area_cuadrado = a => {
  const area = a * a;
  console.log(`El area del cuadrado es de ${area} ${unidad}^2`);
};

const perimetro_cuadrado = a => {
  const area = a * 4;
  console.log(`El perimetro del cuadrado es de ${area} ${unidad}`);
};

/*
  Triangulo
  A = (b*h) / 2
  P = a+b+c
*/
const area_triangulo = (b, h) => {
  const area = (b * h) / 2;
  console.log(`El area del triangulo es de ${area} ${unidad}^2`);
};

const perimetro_triangulo = (a, b, c) => {
  const area = a + b + c;
  console.log(`El perimetro del triangulo es de ${area} ${unidad}`);
};

/*
  cicurlo
  A = Pi*r^2
  P = 2*Pi*r
*/
const area_circulo = r => {
  const area = Math.floor(Math.PI * (r * r));
  console.log(`El area del circulo es de ${area} ${unidad}^2`);
};

const perimetro_circulo = r => {
  const area = Math.floor(2 * Math.PI * r);
  console.log(`El perimetro del circulo es de ${area} ${unidad}`);
};

Encapsulando todo el código y asignando el parámetro como valor a las variables clave, fue mucho más rápido aunque me da cringe que la función tenga tanto código 😂
⠀⠀
Aunque se sigue viendo bonito en la consola.

// Código del Cuadrado.
function measuringSquare(side) {
  const ladoCuadrado = side;

  console.group("Propiedades del cuadrado:");
  console.log(`Los lados del cuadrado miden: ${ladoCuadrado} cm`);

  const perimetroCuadrado = ladoCuadrado * 4;
  console.log(`El perímetro del cuadrado mide:  ${perimetroCuadrado} cm`);

  const areaCuadrado = ladoCuadrado * ladoCuadrado;
  console.log(`El área del cuadrado es: ${areaCuadrado} cm^2`);
  console.groupEnd();
}
measuringSquare(100);

// Código del Triangulo.

const measuringTriangle = (side1, side2, base) => {
  const ladoTriangulo = side1;
  const ladoTriangulo2 = side2;
  const baseTriangulo = base;

  console.group("Propiedades del triángulo:");

  console.log(
    `Los lados del triángulo miden: ${ladoTriangulo} cm, ${ladoTriangulo2} cm, ${baseTriangulo} cm`
  );

  const alturaTriangulo = 5.5;
  console.log(`La altura del triángulo es de: ${alturaTriangulo} cm`);

  const perimetroTriangulo = ladoTriangulo + ladoTriangulo2 + baseTriangulo;
  console.log(`El périmetro del triángulo es de: ${perimetroTriangulo}`);

  const areaTriangulo = (baseTriangulo * alturaTriangulo) / 2;
  console.log(`El área del triángulo es de: ${areaTriangulo} cm^2 `);

  console.groupEnd();
};

measuringTriangle(3, 3, 5);

// Código del Círculo.

const propertiesOfCircle = (radio) => {
  console.group("Propiedades del círculo");
  const PI = Math.PI;
  console.log(`Este es el valor de PI: ${PI}cm `);
  // radio
  const radioCirculo = radio;
  console.log(`El radio del círculo es de: ${radioCirculo}cm `);
  // diametro
  const diametroCirculo = radioCirculo * 2;
  console.log(`El diámetro del círculo es de: ${diametroCirculo}cm `);
  // circunferencia
  const circunferencia = Math.floor(diametroCirculo * PI);
  console.log(`La circunferencia del círculo es de: ${circunferencia}cm `);

  // area
  const areaCirculo = Math.floor(radioCirculo * radioCirculo * PI);
  console.log(`El área del círculo es de: ${areaCirculo}cm `);

  console.groupEnd();
};

propertiesOfCircle(4);

//Codigo del cuadrado
console.group(“cuadrados”);
function cuadrado(ladoCuadrado){

console.log(Los lados del cuadrado miden: ${ladoCuadrado}cm);

let perimetroCuadrado = ladoCuadrado * 4;

console.log(el perimetro de mi cuadrado es : ${perimetroCuadrado}cm);

let areaCuadrado = ladoCuadrado * ladoCuadrado ;

console.log(el area de mi cuadrado es : ${areaCuadrado} cm°2);
}
cuadrado();
console.groupEnd();

//Codigo del cuadrado

//codigo del triangulo

console.group(“triangulos”);
function triangulos(ladoTriangulo1, ladoTriangulo2,baseTriangulo,alturaTriangulo) {

// let ladoTriangulo1 = 6;
// let ladoTriangulo2 = 6;
// let baseTriangulo = 4;
// let alturaTriangulo = 5.5;

console.log(Los lados del triangulo miden: ${ladoTriangulo1}cm + ${ladoTriangulo2}cm + ${baseTriangulo}cm y la altura es ${alturaTriangulo}cm);

let perimetroTriangulo = ladoTriangulo1 + ladoTriangulo2 + baseTriangulo;

console.log(el perimetro de mi triangulo es : ${perimetroTriangulo}cm);

let areaTriangulo = (baseTriangulo * alturaTriangulo) / 2 ;

console.log(el area de mi triangulo es : ${areaTriangulo} cm°2);
}
triangulos(6,6,4,5.5);
console.groupEnd();

// codigo del triangulo

//codigo del circulo

console.group(“circulo”);
function circulo(radioCirculo,pi) {

// let radioCirculo = 4;
console.log(el radio del cirulo es ${radioCirculo}cm);
//diametro circulo
let diametroCirculo = radioCirculo * 2;
console.log(el diametro del cirulo es ${diametroCirculo}cm);
//PI
// let pi = Math.PI;
console.log(el radio del cirulo es ${pi});
//circunferencia
let perimetroCirculo = diametroCirculo * pi;
console.log(el radio del cirulo es ${perimetroCirculo}cm);
//area
let areaCirculo = (radioCirculo + perimetroCirculo) * pi;
console.log(el radio del cirulo es ${areaCirculo}cm°2);
}
circulo(4,Math.PI);
//radio circulo
console.groupEnd();

// codigo del circulo

var perimetroCuadrado = (lado) => (4 * lado);
var areaCirculo = (radio) => ((Math.PI * Math.pow(radio, 2)).toFixed(2));
var areaCuadrado = (lado) => (Math.pow(lado, 2));

console.log("El perimetro del cuadrado es " + perimetroCuadrado(3) + " cm");
console.log("El area del cuadrado " + areaCuadrado(123) + " cm^2");
console.log("El area del circulo es de " + areaCirculo(20) + " cm^2")
<//cuadrado
function cuadrado(lado){
    var areaCuadrado = lado * lado;
    var perimetroCuadrado = lado * 4;
    return console.log(`El area del cuadrado es ${areaCuadrado}cm2 y El perimetro del cuadrado es ${perimetroCuadrado}cm`);
};

//triangulo 
function triangulo(lados,base,altura){
    var areaTriangulo = (base * altura)/2;
    var perimetroTriangulo = (lados*2)+base;
    return console.log(`El area del triangulo es ${areaTriangulo}cm2 y El perimetro  del triangulo es ${perimetroTriangulo}cm`);
};

//Circulo
var PI = Math.PI;
function circulo(radio){
    var diametroCirculo = radio^2;
    var areaCirculo = PI * diametroCirculo;
    var areaCirculo = areaCirculo.toFixed(2);
    return console.log(`El diametro del circulo es ${diametroCirculo}cm y El area del circulo es ${areaCirculo} cm2 `);
};> 

_lo hice con prompt

// codigo cuadrado
console.group("cuadrados");
var ladoCuadrado = prompt ("ingrese el lado del cuadrado");
console.log("los lados del cuadrado miden "
 + ladoCuadrado 
 +"cm");

var perimetroCuadrado = function(ladoCuadrado){ 
     return ladoCuadrado * 4;
 };
console.log("Perimetro del cuadrado miden " 
+ perimetroCuadrado(ladoCuadrado)
+ "cm"
);

var areaCuadrado = function(ladoCuadrado){
    return ladoCuadrado * ladoCuadrado;
};
console.log("area del caudrado miden " 
+ areaCuadrado(ladoCuadrado)
+"cm2");
console.groupEnd;

// codigo triangulo
console.group("triangulos");
var ladoTriangulo1 = prompt("ingrese en primer lado del triangulo");
var ladoTriangulo2 = prompt("ingrese en segundo lado del triangulo");
var baseTriangulo = prompt("ingrese en la base del triangulo");
var alturaTriangulo = prompt("ingrese la altura del triangulo");


var perimetroTriangulo = function(ladoTriangulo1,ladoTriangulo2,baseTriangulo){
    return ladoTriangulo1+ladoTriangulo2+baseTriangulo;
};

var areaTriangulo = function(baseTriangulo,alturaTriangulo){
    return (baseTriangulo*alturaTriangulo)/2
};

console.log("los lados del triangulo miden " 
 + ladoTriangulo1 
 +"cm, "
 + ladoTriangulo2 
 + "cm "
 + baseTriangulo 
 + "cm2 ");
console.log("Perimetro del triangulo es " 
 + perimetroTriangulo(ladoTriangulo1,ladoTriangulo2,baseTriangulo) 
 + "cm");
console.log("area del caudrado miden " 
+ areaTriangulo(baseTriangulo,alturaTriangulo)
+"cm2");

console.groupEnd;

// calcular circulo
console.group("circulos");
var radioCirculo =prompt("ingrese el radio del cuiculo ");

var perimetroCirculo =function(radioCirculo){
    return (2*Math.PI)*radioCirculo;
};
var areaCirculo = function(radioCirculo){
    return Math.PI*(radioCirculo*2);
};

console.log("radio del circulo "
+radioCirculo
+"cm"
);
console.log("perimetro del circulo "
+perimetroCirculo(radioCirculo)
+"cm");
console.log("area del circulo "
+areaCirculo(radioCirculo)
+"cm");

console.groupEnd

Pequeño aporte:
Podemos utilizar Math.pow() para el calculo de potencias: 🤓🤓🤓

Un amigo programador me contó sobre la cantidad de programadores que no saben inglés y como esto podía frenar o paralizar un poco el crecimiento dentro de la industria. Por esta razón les recomiendo comenzar a programar en ingles, úsenlo en todas partes y van a ver como se va volviendo costumbre, compártanlo con sus compañeros y van a perder la vergüenza rápidamente, les comparto mi código de la clase en inglés.

PD: Recuerden que existe la escuela de inglés en Platzi.

//code for the square
console.group("squares")
//console.log("the square sides measure: " + squareSide + "cm" + " each")

function squarePerimeter(side) {
    return side * 4;
}

function squareArea(side) {
    return side * side;
}
console.groupEnd()

//code for triangle

function trianglePerimeter(side1,side2,base) {
    return side1 + side2 + base;
}

function triangleArea(base,height){
    return (base * height) / 2;
}

console.groupEnd();

//Code for circle
console.group("Circles")

//Diameter
function circleDiameter(radius){
    return radius * 2
}

//PI

const PI = Math.PI;

//Perimeter
function circlePerimeter(radius){
    const diameter = circleDiameter(radius)
    return diameter * PI;
}

//Radius
function circleArea (radius) {
    return (radius * radius) * PI
}

console.groupEnd()
  • Cuando recibimos valores en una función se llama parámetros
  • Pero cuando llamamos a una función, lo que enviamos se llama argumentos
/* Codigo del cuadrado */

console.group("Cuadrados");

/* const ladoCuadrado = 5;
console.log("Los lados del cuadrado miden: " + ladoCuadrado + "cm"); */

function perimetroCuadrado(lado) {
    return lado * 4;
}
/* console.log("El perimetro del cuadrado es: " + perimetroCuadrado + "cm"); */

function areaCuadrada(lado) {
    return lado * lado; 
}
/* console.log("El area del cuadrado es: " + areaCuadrada + "cm^2"); */

console.groupEnd();

/* Codigo del triangulo */

console.group("Triangulos");

/* const ladoTriangulo1 = 6;
const ladoTriangulo2 = 6;
const baseTriangulo = 4;
const alturaTriangulo = 5.5; */

/* console.log(
    "Los lados del triangulo miden: " 
    + ladoTriangulo1 
    + "cm, " 
    + ladoTriangulo2 
    + "cm y "
    + baseTriangulo
    + "cm"
); */

/* console.log("La altura del triangulo es de: " + alturaTriangulo + "cm"); */

function perimetroTriangulo(lado1, lado2, base) {
   return lado1 + lado2 + base; 
}
/* console.log("El perimetro del triangulo es: " + perimetroTriangulo + "cm"); */

function areaTriangulo(base, altura) {
    return (base * altura) / 2;   
}
/* console.log("El area del triangulo es: " + areaTriangulo + "cm^2"); */

console.groupEnd();

/* Codigo del circulo */

console.group("Circulos");

/* const radioCirculo = 4;
console.log("El radio del circulo es: " + radioCirculo + "cm"); */

function diametroCirculo(radio) {
  return  radio * 2
}
/* console.log("El diametro del circulo es: " + diametroCirculo + "cm"); */

const PI = Math.PI;
/* console.log("El numero PI es: " + PI); */

function perimetroCirculo(radio) {
    const diametro = diametroCirculo(radio);
    return diametro * PI
}    
/* console.log("El perimetro del circulo es: " + perimetroCirculo + "cm"); */

function areaCirculo(radio) {
    return (radio * radio) * PI;
}    
/* console.log("El area del circulo es: " + areaCirculo + "cm^2"); */


console.groupEnd();

Freddy Vega una vez dijo que el 80% del tiempo estaremos leyendo código y un 20% escribiéndolo.