Fórmulas matemáticas en JavaScript

class Rectangle {
  constructor(base, height) {
    this.base = base;
    this.height = height;
  }

  get perimeter() {
    return `${this.calcPerimeter(this.base, this.height)}cm`;
  }

  get area() {
    return `${this.calcArea(this.base, this.height)}cm2`;
  }

  calcPerimeter(base, height) {
    return base * 2 + height * 2;
  }

  calcArea(base, height) {
    return base * height;
  }
}

class Circle {
  constructor(radio) {
    this.radio = radio;
  }

  get perimeter() {
    return `${this.calcPerimeter(this.radio)}cm`;
  }

  get area() {
    return `${this.calcArea(this.radio)}cm2`;
  }

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

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

Recomiendo usar la fórmula de Heron para calcular el área del triángulo, ya que nos soluciona el problema que se presenta cuando tenemos triángulos del tipo escaleno, y al mismo tiempo, nos permite dejar de lado términos como base y altura, así nos concentramos únicamente en las medidas de los lados

El operador de potenciación es doble asterisco

// el cuadrado de 5
let areaCuadrado = 5 ** 2;
// areaCuadrado = 25;

CTRL+D : Para seleccionar varias palabras 1 por 1 con el cursor
CTRL+CLIK: Para escribir donde hacemos click, si no nos funciona, en el menu superior buscamos 'Selection" y hacemos click en ‘Switch to Ctrl+Click for Multi-Cursor’

Si quieren personalizar sus Logs puede hacerlo de la siguiente manera.

console.log( '%c juanda', 'color: blue; font-size: 20px;');

de esta forma usando el %c seguido de una coma pueden obtener esto:

Como aporte el método console.groupEnd() no requiere argumentos no sirve de nada pasarle el nombre del grupo. Podéis verlo haciendo hover sobre el método en el editor o entrando a la documentación.

let ladoC = document.querySelector('#lado-cuadrado');
let perimetroC = document.querySelector('.perimetro-cuadrado');
let areaC = document.querySelector('.area-cuadrado');
let valorC = document.querySelectorAll('.valor');

ladoC.addEventListener('change',()=>{
    if (ladoC.value > 0){
        perimetroC.innerHTML = ladoC.value * 4;
        areaC.innerHTML = ladoC.value * ladoC.value;
    
        for(i=0; i < valorC.length;i++){
            valorC[i].innerHTML = ladoC.value
        }
    
    }

})

Si mal no recuerdo en una clase de la pre… Existia un teorema conocido como el teorema de Heron que permite brindarte el area mediante solamente sus lados.

Con ello permitia obtener el area facilmente con el uso de sus lados…

Las multiplicaciones son conmutativas, es decir, no importa el orden de los factores, el resultado es el mismo.

En el ejemplo que mencionan de “base * altura / 2” no hace falta colocar paréntesis, el resultado es el mismo si se hace (base * altura)/2 o (base/2) * altura o base * (altura/2).

La división entre dos se puede ver en este caso como una fracción 1/2, por lo que la multiplicación sería equivalente a:
base * altura * (1/2)

Al ser conmutativa, no importa el orden, el resultado es el mismo.

Muy distinto sería si ya se involucrara alguna otra operación, por ejemplo (base + altura)/2. Aquí si sería importante colocar los paréntesis.

utilizando callback, que aprenderán en cursos posteriores
SIGAN APRENDIENDO

function calcular (base, altura, callback){
  return callback(base,altura)
}

const area = (a, b) => a*b
const perimetro = (a, b) => 2*a+2*b

calcular(2,2,area)             		 //4
calcular(2,2,perimetro)    			   //8
calcular(3,4,perimetro)  				  //14
calcular(3,5,area)      		  		//15
  

Hola!, también podemos utilizar el objeto global Math para la potencia con:
const areaCuadrado = Math.pow(ladoCuadrado, 2)

Codigo para cualquier figura regular

solo fucion si la figura tiene todos los lados son iguales

const degreesToRadians = (degrees) => degrees * Math.PI / 180;

class RegularPolygon {
    constructor(numSides, sideLength, unit = "cm") {
        this.sideLength = sideLength;
        this.numSides = numSides;
        this.unit = unit;

        this.angle = 360 / (2 * numSides);
        this.perimeter = this.calculatePerimeter(sideLength, numSides);
        this.apothem = this.calculateApothem(sideLength, this.angle);
        this.area = this.calculateArea(this.perimeter, this.apothem);
    }

    calculateApothem = (sideLength, angle) => sideLength / (2 * Math.tan(degreesToRadians(angle)));

    calculatePerimeter = (sideLength, numSides) => sideLength * numSides;

    calculateArea = (perimeter, apothem) => perimeter * apothem / 2;

    printInfo = (numDecimals , unit = this.unit) => console.log(
`Number of sides: ${this.numSides.toFixed(numDecimals)}
Side length: ${this.sideLength.toFixed(numDecimals)}${unit}
Apothem: ${this.apothem.toFixed(numDecimals)}${unit}
Perimeter: ${this.perimeter.toFixed(numDecimals)}${unit}
Area: ${this.area.toFixed(numDecimals)}${unit}^2`)
}

unos ejemplos de como usar el metodo printinfo() para mostrar los datos de cada figura

const square1 = new RegularPolygon(4,10,'cm');
square1.printInfo(1)

const triangle1 = new RegularPolygon(3,1,'cm');
triangle1.printInfo(2)

const square2 = new RegularPolygon(4,8.5,"m")
square2.printInfo(5)

Explicación de distintos tipos de console

Les comparto mi solución del triangulo:

const ladoTriangulo1  = 12;
const ladoTriangulo2  = 12;
const baseTriangulo   = 8;
const alturaTriangulo = Math.sqrt((ladoTriangulo1 * ladoTriangulo1) - ((baseTriangulo / 2) * (baseTriangulo / 2)));

const perimetroTriangulo = `${ladoTriangulo1 + ladoTriangulo2 + baseTriangulo} cm`;
const areaTriangulo = `${((baseTriangulo * alturaTriangulo) / 2).toFixed(2)} cm²`;

Espero que le sirva a alguien, saludos.

class Square {
  constructor(size) {
    this.size = size;
  }

  get perimeter() {
    return `${this.calcPerimeter(this.size)}cm`;
  }

  get area() {
    return `${this.calcArea(this.size)}cm2`;
  }

  calcPerimeter(size) {
    return size * 4;
  }

  calcArea(size) {
    return size * size;
  }
}

class Triangle {
  constructor(base, height, size2, size3) {
    this.base = base;
    this.height = height;
    this.size2 = size2;
    this.size3 = size3;
  }

  get perimeter() {
    return `${this.calcPerimeter(this.base, this.size2, this.size3)}cm`;
  }

  get area() {
    return `${this.calcArea(this.base, this.height)}cm2`;
  }

  calcPerimeter(size, size2, size3) {
    return size + size2 + size3;
  }

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

clase general para cualquier figura regular

solo fucion si la figura tiene todos los lados son iguales

const degreesToRadians = (degrees) => degrees * Math.PI / 180;

class RegularPolygon {
    constructor(numSides, sideLength, unit = "cm") {
        this.sideLength = sideLength;
        this.numSides = numSides;
        this.unit = unit;

        this.angle = 360 / (2 * numSides);
        this.perimeter = this.calculatePerimeter(sideLength, numSides);
        this.apothem = this.calculateApothem(sideLength, this.angle);
        this.area = this.calculateArea(this.perimeter, this.apothem);
    }

    calculateApothem = (sideLength, angle) => sideLength / (2 * Math.tan(degreesToRadians(angle)));

    calculatePerimeter = (sideLength, numSides) => sideLength * numSides;

    calculateArea = (perimeter, apothem) => perimeter * apothem / 2;

    printInfo = (numDecimals , unit = this.unit) => console.log(
`Number of sides: ${this.numSides.toFixed(numDecimals)}
Side length: ${this.sideLength.toFixed(numDecimals)}${unit}
Apothem: ${this.apothem.toFixed(numDecimals)}${unit}
Perimeter: ${this.perimeter.toFixed(numDecimals)}${unit}
Area: ${this.area.toFixed(numDecimals)}${unit}^2`)
}

unos ejemplos de como usar el metodo printinfo() para mostrar los datos de cada figura

const square1 = new RegularPolygon(4,10,'cm');
square1.printInfo(1)

const triangle1 = new RegularPolygon(3,1,'cm');
triangle1.printInfo(2)

const square2 = new RegularPolygon(4,8.5,"m")
square2.printInfo(5)

reto triangulo

class triangle {
    constructor(side1, side2, side3,unit) {
        this.sides = [side1, side2, side3]
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
        this.unit = unit;
        
        this.perimeter = this.calculatePerimeter(this.sides)
        this.semiPerimeter = this.perimeter/2;
        this.area = this.calculateArea(this.sides,this.semiPerimeter);
    }
    calculatePerimeter = (sides ) => sides[0]+sides[1]+sides[2]
    calculateArea = (sides , semiPerimeter)=> Math.sqrt((semiPerimeter-sides[0])*(semiPerimeter-sides[1])*(semiPerimeter-sides[2])*semiPerimeter , 2)
    printInfo = (numDecimals, unit = this.unit) => console.log(
`
Number of sides: ${this.sides.length}
Sides length: ${this.sides[0]+ unit} ${this.sides[1]+ unit} ${this.sides[2]+ unit}
Perimeter: ${this.perimeter.toFixed(numDecimals)}${unit}
Area: ${this.area.toFixed(numDecimals)}${unit}^2
`
    )
}

ejemplo de como usar el metodo printinfo() para mostrar la informacion del triangulo en consola

const t1 = new triangle(2,4,3);
t1.printInfo(2,'m')

Fórmulas para el cuadrado

Fórmulas para el triangulo

Proyecto final: Portal del docente

📌Demo: Prueba la aplicación🎮
📌Repositorio: Mira el código completo💻
📌Descripción:
El proyecto consiste en un portal en el que se pueden ingresar las calificaciones(grades) de los alumnos de una clase y en la sección de estadísticas se puede obtener el promedio, media y moda (uni, bi y multimodal) de la clase presionando los respectivos botones. Adicionalmente se agregó un icono de signo de interrogación el cual, al ser presionado, muestra una tarjeta con la definición de cada concepto
_
📌Vistas:

• Desktop
  

  

• Mobile
  

  

Se puede hallar una aproximación del area de un triangulo si conoces los 3 lados con la formula de Heron.

1. Calculas el perimetro
   Perimetro = 6 + 6 + 4
   Perimetro = 16

2. Calculas el semiperimetro s (la mitad del perimetro)
   s = 16/2
   s = 8

3. Aplicas la formula que es [s*(s-l1)(s-l2)(s-l3)]^1/2
   A = [8*(8-6)(8-6)(8-4)]^1/2
   A = (822*4)^1/2
   A = (128)^1/2
   A = 11.31

Es una aproximación

<//calculadora de figuras geometricas (Cuadrado y triangulo)
function areasYPerimetros() {
  //variables del cuadrado
  let lado;
  //variables generales
  let perimetro;
  let area;
  let eleccion;
  //variables del triangulo
  let lado1;
  let lado2;
  let base;
  let altura;

  //Digita el numero uno para calcular el cudrado, digita el numero 2 para el triangulo.
  eleccion = prompt("Que perimetro  y area deseas calcular");

  if(eleccion == 1){
    lado = prompt("Digita un numero");
    perimetro = lado * 4;
    area = lado * lado
    console.log("El area es: " + area)
    console.log("El perimetro es:" + perimetro);
  }else if(eleccion == 2){
    lado1 = parseFloat(prompt("Digita el primer lado: "));
    lado2 =  parseFloat(prompt("Digita el segundo lado: "));
    base =  parseFloat(prompt("Digita la base: "));
    altura = parseFloat(prompt("Digita la altura: "));
    area = (base * altura) / 2;
    perimetro = lado1 + lado2 + base;
    console.log("El area es: " + area);
     console.log("El perimetro es: " + perimetro);
  }
}

areasYPerimetros();
> 

Como ven en la imagen lo hice un poco diferente Juan DC, en debe de usar los returns, use los console.log con objetos adentro. Si haa alguna razon de porque es mejor usar el return agradeceria que me dijeran.

function cal(figure,find,base,height,otherSide){
let area
let perimeter
    switch (figure) {
    case "square":  
        area = base*base;
        perimeter = 4*base
        break;
    case "rectangle":   
        area=base*height
        perimeter= 2*base + 2*height 
        break;
    case "triangle":    
        area=(base*height)/2
        perimeter=base+height+otherSide
        break;
    default: NaN
        break;        
    } 


    if(find == "area"){
        return area
    } else if(find == "perimeter"){
        return perimeter
    }else{
        return NaN
    }
}

Queria asegurarme antes de comentarlo xD. En fin si retiras los parentesis en este caso en particular no afectara el resultado por la cantidad de elementos a operar antes de la division, la multiplicacion y la division tiene la misma prioridad pero se inicia de izquierda a derecha por lo que en este caso en particular quitar los parentesis no afecta al resultado peeeeeeero esto no quiere decir que siempre sera asi, incluso matematicamente hablando no poner parentesis seria un error.

Este es mi codigo. Dividi las cosas por Rectangulo, Triangulo y Circulo. Utilice una funcion para cada cosa, y agregue un evento click, para obtener el resultado por separado.

let base = document.querySelector(".base");
let height = document.querySelector(".altura");
let perimeter = document.querySelector(".perimerC");
const resultado1 = document.querySelector(".resul1");
let area = document.querySelector(".areC");

resultado1.addEventListener("click", cuadradoP);

function cuadradoP(){
     perimeter.innerHTML = (base.value *2) + (height.value *2);
     area.innerHTML = (base.value) * (height.value);
}


//Perimetro y area de un triangulo
let lado1 = document.querySelector(".ladoA");
let lado2 = document.querySelector(".ladoB");
let lado3 = document.querySelector(".ladoC");
let areaT = document.querySelector(".areT");
let perimeterT = document.querySelector(".perimerT");
const resultado2 = document.querySelector(".resul2");

resultado2.addEventListener("click", trianguloP)

function trianguloP(){
    perimeterT.innerHTML = (parseInt(lado1.value) + parseInt(lado2.value) + parseInt(lado3.value));
    const s = ((parseInt(lado1.value) + parseInt(lado2.value) + parseInt(lado3.value)) / (2));
    areaT.innerHTML = Math.pow((s*(s-lado1.value)*(s-lado2.value)*(s-lado3.value)), (1/2));
}



//Calculando el area del circulo
let radio = document.querySelector(".radio");
let are = document.querySelector(".areCir")
let per = document.querySelector(".perimercir")
const resultado3 = document.querySelector(".resul3")

resultado3.addEventListener("click", circuloA);

function circuloA(){
    are.innerHTML = (Math.PI) * (Math.pow(radio.value, 2));
    per.innerHTML = 2*(Math.PI) * radio.value;
}

Para profundizar un poco más en los diferentes tipos de consolas

• Tipos de objetos console en JavaScript. Parte I.
• Tipos de objetos console en JavaScript. Parte II.

Funcion Cuadrado

Funcion Triangulo

Simples pero se puede mejorar!

me gusta el análisis de Juan, para el área del triangulo, interesante.

El operador de potenciación en JavaScript es el doble asterisco ( ** ), entonces el área de un cuadradro sería:

const areaCuadrado = ladoCuadrado**2;

En realidad si hay una restricción para las medidas del lado de un triangulo. Ningún lado puede medir más que la suma de los otros dos.

Console.group('inicio') //Aqui van las impresiones por pantalla Console.Endgroup('final')

Manera de crear la impresión por pantalla de un objeto

La fórmula básica del perímetro para cualquier figura que contenga ángulos, es sumar los lados. Si la figura tiene 5 lados, debemos sumar L + L + L + L + L. Si todos los lados tienen la misma longitud, entonces podemos simplificar con una multiplicación; en la cual un producto será el valor de los lados y el otro producto la cantidad de lados. Como en este ejemplo tenemos cinco, multiplicamos L * 5, siendo L el producto cual valor llevan los lados, y 5 la cantidad de lados de la figura.

Notes about class

// Square
const squareSide = 5;
const squarePerimeter = squareSide * 4 + 'cm';
const squareArea = squareSide * squareSide + 'cm2';
console.log({squareSide, squarePerimeter, squareArea})

function squareCalcs(side){
    return{
        perimeter: side * 4 + 'cm',
        area: side * side + 'cm2'
    };
};

//Triangle
const triangleSide1 = 6;
const triangleSide2 = 6;
const triangleSideBase = 4;
const triangleHeight = 5.5;
const trianglePerimeter = triangleSide1 + triangleSide2 + triangleSideBase + 'cm';
const triangleArea = ( triangleSideBase * triangleHeight ) / 2
console.log({triangleSide1, triangleSide2, triangleSideBase, triangleHeight,trianglePerimeter, triangleArea})

function triangleCalcs(side1, side2, base, height){
    return{
        perimeter: side1 + side2 + base + 'cm',
        area: ( base * height ) / 2 + 'cm2'
    };
};

Que genial funciona console.group nunca lo había utilizado!!

Aplicativo que pregunta que desea ejecutar y solicita los datos de cada metodo que vaya a utilizar.

let calcular;

do {
    while (true) {
        calcular = prompt(`Qué deseas ejecutar?
                            1. Perímetro de un Cuadrado.
                            2. Área de un Cuadrado.
                            3. Perímetro de un Triángulo.
                            4. Área de un Triángulo.
                            0. Salir.`);

        calcular = parseInt(calcular);

        if (calcular >= 0 && calcular <= 4) {
            break; 
        } else {
            alert('El código digitado es inválido, por favor verifique e intente nuevamente.');
        }
    }

    switch (calcular) {
        case 1:
            PerimetroCuadrado();
            break;
        case 2:
            AreaCuadrado();
            break;
        case 3:
            PerimetroTriangulo();
            break;
        case 4:
            AreaTriangulo();
            break;
        case 0:
            alert('Ha salido.');
            window.close();
            break;
    }
} while (calcular !== 0);

function PerimetroCuadrado() {
    let ladoCuadrado = prompt(`Ingrese el lado de un cuadrado en cm.`);
    ladoCuadrado = parseInt(ladoCuadrado);
    const perimetroCuadrado = ladoCuadrado * 4;
    alert('El perímetro del cuadrado es: ' + perimetroCuadrado + ' cm.');
}

function AreaCuadrado() {
    let ladoCuadrado = prompt(`Ingrese el lado de un cuadrado en cm.`);
    ladoCuadrado = parseInt(ladoCuadrado);
    const areaCuadrado = ladoCuadrado * ladoCuadrado;
    alert('El área del cuadrado es: ' + areaCuadrado + ' cm².');
}

function PerimetroTriangulo() {
    let ladoTriangulo1 = prompt(`Ingrese el lado izquierdo del triángulo en cm.`);
    let ladoTriangulo2 = prompt(`Ingrese el lado derecho del triángulo en cm.`);
    let ladoTrianguloBase = prompt(`Ingrese la base del triángulo en cm.`);

    ladoTriangulo1 = parseInt(ladoTriangulo1);
    ladoTriangulo2 = parseInt(ladoTriangulo2);
    ladoTrianguloBase = parseInt(ladoTrianguloBase);
    
    const perimetroTriangulo = ladoTriangulo1 + ladoTriangulo2 + ladoTrianguloBase;
    alert('El perímetro del triángulo es: ' + perimetroTriangulo + ' cm.');
}

function AreaTriangulo() {
    let ladoTrianguloBase = prompt(`Ingrese la base del triángulo en cm.`);
    let alturaTriangulo = prompt(`Ingrese la altura del triángulo en cm.`);

    ladoTrianguloBase = parseInt(ladoTrianguloBase);
    alturaTriangulo = parseInt(alturaTriangulo);
    
    const areaTriangulo = (ladoTrianguloBase * alturaTriangulo) / 2;
    alert('El área del triángulo es: ' + areaTriangulo + ' cm².');
}

Hola espero todos esten bien!
Run code, es una extension para vs code, que les va a permitir correr codigo javascript (Que no use funciones del agente (explorador)) en el mismo vs code, sin tener que estar pasandose a una ventana de un explorador para abrirlo.

Good luck!

const triangle = (lad1, lad2, lad3, altura, base)=>{
    const perimeter = lad1 + lad2 + lad3;
    
    const area = (altura* base)/2;
    
    return `Perimetro: ${perimeter} - Area: ${area}`;
}

viendo esta clase y habiendo estudiado “el curso practico de js” se entiende mas rápido todo 😁

Que gran clase, aprendí muchísimo.

/////////////// Square ///////////////

// Square
const squareSide = 5;

// CalculateSquarePerimeter
const squarePerimeter = squareSide * 4;

// CalculateSquareArea
const squareArea = squareSide + squareSide;

/////////////// Triangle ///////////////

// Triangle
const triangleSide1 = 6;
const triangleSide2 = 6;
const triangleBase = 4;
const triangleHeight = 5.5;

// CalculateTrianglePerimeter
const trianglePerimeter = triangleSide1 + triangleSide2 + triangleBase;

// CalculateTriangleArea
const triangleArea = (triangleBase * triangleHeight) / 2;

/////////////// Print Results ///////////////

// PrintResult
console.log({
	squareSide,
	squarePerimeter,
	squareArea,
	trianglePerimeter,
	triangleArea,
});

/////////////// Calculate Functions ///////////////

// CalculateTriangle

function calculateTriangle(side1, side2, base, height){
	return {
		Perimeter: side1 + side2 + base,
		Area: (base * height) / 2,
	};
};

// CalculateSquare

function calculateSquare(side1, side2, side3){
	return {
		Perimeter: side1 * 4,
		Area: side1 + side2,
	};
};

.

2. Fórmulas matemáticas en JavaScript

Practice:

Realicé este ejercicio practicando cosas que vimos en un curso anterior.

<body>
    <header>
        <h1>Calculator</h1>
    </header>
    <main class="square">
        <h2>Square</h2>
        <section>
            <label for="side">Enter a side</label><br>
            <input type="number" id="side" class="side"><br>
            <button class="send-one">Send</button>
        </section>
        <section>
            <h3>Perimeter of the square</h3>
            <p class="result-one"></p>  
        </section>
        <section>
            <h3>Area of the square</h3>
            <p class="result-two"></p>
        </section>
    </main>

    <main class="isosceles">
        <h2>Triangle: Isosceles</h2>
        <section>
            <label for="side-triangle">Enter the sides (a, b) and the base</label>
            <input type="number" placeholder="side a, b" id="side-triangle" class="sides">
            <input type="number" placeholder="base" id="side-triangle" class="base"><br>
            <button class="send-three">Send</button>
        </section>
        <section>
            <h3>Perimeter of the triangle</h3>
            <p class="result-tri-one"></p>
        </section>
        <section>
            <h3>Area of the triangle</h3>
            <p class="result-tri-two"></p>
        </section>
    </main>

    <script src="./square_triangle.js"></script>
</body>

// SQUARE
// Perimeter of the square
const side = document.querySelector('.side');
const send = document.querySelector('.send-one');
const result_one = document.querySelector('.result-one')

send.addEventListener('click', calculate_perimeter);

function calculate_perimeter(){
    result_one.innerText = 'The Perimeter of the square is: '+ Number(side.value) * 4;
}

// Area of the square
const result_two = document.querySelector('.result-two');

send.addEventListener('click', calculate_area);

function calculate_area(){
    result_two.innerText = 'The Area of the square is: '+ Math.pow(Number(side.value), 2);
}

// TRIANGLE: ISOSCELES 
// Perimeter of the triangle 
const sides = document.querySelector('.sides')
const base = document.querySelector('.base')
const send_tri = document.querySelector('.send-three');
const result_three = document.querySelector('.result-tri-one');

send_tri.addEventListener('click', calculate_perimeter_triangle);

function calculate_perimeter_triangle(){
    result_three.innerText = 'The Perimeter of the triangle isosceles is: ' + (Number(sides.value) + Number(sides.value) + Number(base.value));
}

// Area of the triangle 
const result_four = document.querySelector('.result-tri-two');

send_tri.addEventListener('click', calculate_area_triangle);

function calculate_area_triangle(){
    // h=sqrt(pow(ab, 2)-pow(base/2, 2))
    const height = Math.sqrt(Math.pow(Number(sides.value), 2) - ((Math.pow(Number(base.value), 2) / 4))).toFixed(2);

    result_four.innerText = `The Area of the triangle isosceles is: ${(Number(base.value) * height) / 2}`;
}

El operador de potenciación es el doble asterisco

// const areaCuadrado = 5 ** 2;
// areaCuadrado = 25;

Mis fórmulas:

'use strict';

// Formulas
function square(side) {
    const perimeter = side * 4;
    const area = side ** 2;

    const result = `Square side: ${side} | perimeter: ${perimeter}, area: ${area}`;
    console.log(result);
}
square(5);

function triangle(side1, side2, side3) {
    const perimeter = side1 + side2 + side3;
    // Heron formula
    const S = perimeter / 2;
    const area = Math.sqrt(S*(S - side1)*(S - side2)*(S - side3))

    const result = `Triangle sides: ${side1}, ${side2}, ${side3},  | perimeter: ${perimeter}, area: ${area}`;
    console.log(result);
}
triangle(5, 6, 8);

Mi código:

//! Formulas
const {log} = console // deestructurando para uso mas agíl
log("hola")

//? Perimetro de un cuadrado
    console.group("Cuadrado")
function squerePerimeter(side) {
    let perimeter = side * 4;
    log(`Your side is ${side}. The perimeter is ${perimeter}`)
}
squerePerimeter(5)

//?Area de un cuadrado
function squareArea(side) {
    let area = side ** 2
    log(`Your side is ${side}. The area is ${area}`)
}
squareArea(5)
    console.groupEnd("Cuadrado")
//? perimetro de un triangulo
    console.group("Triangle")
function trianglePerimeter(side1, side2, side3) {
    let perimeter = side1 + side2 +side3;
    log(`Your sides are ${side1}, ${side2}, ${side3}. The perimeter is ${perimeter}`)
}
trianglePerimeter(5, 4, 3);

//? area de un triangulo
function triangleArea(base, high) {
    let area = (base * high) / 2;
    log(`Your base is ${base} and your high ${high}. The area is ${area}`)
}
triangleArea(4, 6)
    console.groupEnd("Triangle")

Mi codigo

<script>
        console.group('cuadrado')
        //Perimetro y perimetro del cuadrado
        const lado = 5;
        const perimetroyAreaCuadrado = function (lado){
            console.log({
                perimetro : lado * 4,
                area : lado * 2  
            })
        }
        perimetroyAreaCuadrado(lado);
        console.groupEnd
        console.group('Triangulo')
       //perimetro y area del triangulo 
        const perimetroyAreaTriangulo = function (ladot1, ladot2, baset){
            console.log({
                perimetro: ladot1 + ladot2 + baset,
                area: (baset*ladot1)/2
            })
        }
        perimetroyAreaTriangulo(14,14,13)
        console.groupEnd
    </script>

![](

no huir al ver mates D:

Pueden usar ALT+253 para poder escribir el cuadrado en las unidades de área, por ejemplo: cm².

Lo que voy a compartir es demasiado simple pero me ahorró horas de escribir console.log una y otra vez… 😄

const c = console.log;

c('Mensaje en consola!')

Aquí mi pequeño aporte, no se así se vea más ordenado 😃

const formulaCuadrado = (ladocuadrado,cuadrado)=>{
    let perimetrocuadrado = ladocuadrado * cuadrado;
    let areacuadrado = ladocuadrado * ladocuadrado;
    console.log(`El perimetro cuadrado es: ${perimetrocuadrado}`);
    console.log(`El area del cuadrado es: ${areacuadrado}`);
}
formulaCuadrado(5,4); 


const formularTriangulo = (ladoTrianguloUno,ladoTrianguloDos,ladoTrianguloBase,alturaTriangulo) =>{
    let perimetrotriagulo = ladoTrianguloUno + ladoTrianguloDos + ladoTrianguloBase;
    let areatriangulo = (ladoTrianguloBase * alturaTriangulo) / 2;
    console.log(`El perimetro del triangulo: ${perimetrotriagulo}`);
    console.log(`El area del triangulo: ${areatriangulo}`);      
}
formularTriangulo(6,6,4,5.5);

es posible combinar el uso de un closure con la opción del objeto literal para crear una calculadora de área y perímetro.

Una forma de hacerlo es crear un closure que devuelva un objeto literal con las funciones de cálculo para cada figura geométrica.

const calculadora = (function() {
    const funciones = {
        cuadrado: (lado) => {
            return {
                area: lado * lado,
                perimetro: lado * 4
            };
        },
        triangulo: (base, altura) => {
            return {
                area: (base * altura) / 2,
                perimetro: base + altura + Math.sqrt(base ** 2 + altura ** 2)
            };
        },
        rectangulo: (base, altura) => {
            return {
                area: base * altura,
                perimetro: 2 * (base + altura)
            };
        }
    };
    return { 
        calcular: (figura, ...args) => funciones[figura](...args) 
    };
})();

En este ejemplo, se crea un closure con un objeto literal “funciones” que contiene las funciones de cálculo para cada figura geométrica. Luego, se devuelve un objeto con una propiedad “calcular” que recibe como parámetros la figura geométrica y los argumentos necesarios para realizar el cálculo. La función calcular se encarga de buscar en el objeto “funciones” la función correspondiente a la figura geométrica seleccionada y ejecutarla con los argumentos recibidos.

De esta forma, se puede seleccionar la figura geométrica utilizando una variable o un desplegable en HTML y luego acceder a la función de cálculo correspondiente en el closure “calculadora” utilizando la propiedad calcular():

let figura = "cuadrado";
let lado = 5;
let resultado = calculadora.calcular(figura, lado);
console.log(resultado);

De esta forma, se combina la facilidad de selección de la figura geométrica de manera explícita con la forma de almacenar las funciones en un objeto literal, para tener una solución que se adapta a tus necesidades.

let figura = "triangulo";
let base = 5;
let altura = 10;
let resultado = calculadora.calcular(figura, base, altura);
console.log(resultado);

En este ejemplo, estamos asignando la variable “figura” con el valor “triangulo”, y utilizando los valores de base y altura para calcular el area y perimetro del triangulo, y accediendo a la función de cálculo correspondiente en el closure “calculadora” utilizando la propiedad calcular, esto nos devuelve un objeto con las propiedades area y perimetro.

Al igual que en el caso del cuadrado y rectangulo es necesario que el usuario introduzca tanto la base como la altura, ya que ambos son necesarios para calcular el área y perímetro de un triangulo.

Se puede potenciar a la dos con la función Math.pow(ladoCuadrado, 2)

Juan Disclaimers Castro

En este caso en particular no importa el orden de los factores, así que los paréntesis son algo más estético que otra cosa