Costruire un calcolatore di area di geometria JavaScript: Tutorial per sviluppatori interattivi 2025
Anh Quân
Creator
Sommario
- Introduzione: perché costruire un calcolatore di geometria?
- Cosa costruiremo
- Prerequisiti
- Comprensione della matematica dietro i calcoli dell'area
- Configurazione del progetto
- Implementazione di JavaScript
- Comprendere i componenti chiave
- Aggiunta di funzionalità avanzate
- Test e validazione
- Ottimizzazione per dispositivi mobili
- Ulteriori miglioramenti
- Applicazioni pratiche
- Conclusione
- Risorse per ulteriori apprendimenti
Una guida approfondita per la creazione del tuo calcolatore di geometria interattiva utilizzando JavaScript, completa di calcoli dell'area per poligoni semplici e complessi.
Introduzione: perché costruire un calcolatore di geometria?
I calcoli della geometria formano la base di numerose applicazioni del mondo reale: da indagini sulla terra e architettura allo sviluppo del gioco e ai sistemi di informazione geografica.Come sviluppatori, spesso abbiamo bisogno di strumenti affidabili per calcolare le aree di varie forme.Mentre ci sono molti calcolatori online disponibili, costruire le proprie offerte diversi vantaggi:
- Completa personalizzazione per soddisfare i requisiti specifici del progetto
- Flessibilità di integrazione con le tue applicazioni Web esistenti
- Opportunità di apprendimento per comprendere la geometria coordinata e il pensiero algoritmico
- Miglioramento del portafoglio per mostrare le tue abilità JavaScript
In questo tutorial completo, attraverseremo il processo di costruzione di un potente calcolatore di area di geometria interattiva usando JavaScript.Alla fine, avrai un'applicazione Web completamente funzionale che calcola accuratamente l'area dei poligoni semplici e complessi usando la geometria delle coordinate.
Cosa costruiremo
La nostra calcolatrice di geometria lo farà:
- Consenti agli utenti di inserire le coordinate poligoniche attraverso un'interfaccia intuitiva
- Calcola le aree per poligoni regolari e irregolari
- Supportare più unità di misurazione
- Visualizza le forme usando la tela HTML
- Fornire risultati chiari e accurati con un arrotondamento adeguato
- Lavorare su tutti i principali browser e dispositivi
Un'anteprima del nostro calcolatore finale di area di geometria JavaScript con input poligono interattivo
Prerequisiti
Per seguire questo tutorial, dovresti:
- Comprensione di base di HTML, CSS e JavaScript
- Familiarità con la manipolazione DOM
- Editor di testo o IDE (Codice VS, testo sublime, ecc.)
- Browser Web moderno
- Opzionale: comprensione delle basi della geometria delle coordinate
Comprensione della matematica dietro i calcoli dell'area
Prima di immergerti nel codice, comprendiamo i principi matematici che alimentano il nostro calcolatore di geometria.
La formula per la riva per la riva per la shoelace per poligono
Per il calcolo dell'area di qualsiasi poligono (normale o irregolare), useremo la formula per la scarina, nota anche come formula del geometra o formula dell'area di Gauss.Questo potente algoritmo funziona per qualsiasi poligono definito dai suoi vertici, indipendentemente da quanto possa essere complessa la forma.
La formula è espressa come:
Area = 0.5 * |∑(x_i * y_(i+1) - x_(i+1) * y_i)| Dove:
x_iandy_iare the coordinates of the i-th vertex- La formula calcola la metà della somma dei prodotti trasversali dei vertici adiacenti
- Il valore assoluto garantisce un'area positiva
Questa formula funziona "camminando" attorno al perimetro del poligono, calcolando i prodotti incrociati tra punti consecutivi.Quando li riassumiamo e ci dividiamo per 2, otteniamo l'area del poligono.
Configurazione del progetto
Iniziamo impostando la struttura di base del nostro calcolatore di geometria:
Struttura HTML
Create a new file named index.html with the following structure:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Geometry Area Calculator</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<div class="calculator-container">
<h1>Geometry Area Calculator</h1>
<div class="input-section">
<h2>Enter Polygon Coordinates</h2>
<p>Click on the canvas to add points or enter them manually below.</p>
<div class="canvas-container">
<canvas id="polygon-canvas" width="400" height="400"></canvas>
<button id="clear-canvas">Clear Canvas</button>
</div>
<div class="manual-input">
<div class="coordinates-container" id="coordinates-list">
<div class="coordinate-pair">
<input type="number" placeholder="X1" class="x-coord">
<input type="number" placeholder="Y1" class="y-coord">
<button class="remove-point">×</button>
</div>
</div>
<button id="add-point">Add Point</button>
</div>
<div class="units-selection">
<label for="units">Measurement Units:</label>
<select id="units">
<option value="pixels">Pixels</option>
<option value="meters">Meters</option>
<option value="feet">Feet</option>
</select>
</div>
<button id="calculate-area">Calculate Area</button>
</div>
<div class="results-section" id="results">
<!-- Results will be displayed here -->
</div>
</div>
<script src="script.js"></script>
</body>
</html>Styling CSS
Create a file named styles.css for styling our calculator:
* {
box-sizing: border-box;
margin: 0;
padding: 0;
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
}
body {
background-color: #f5f5f5;
padding: 20px;
}
.calculator-container {
max-width: 800px;
margin: 0 auto;
background-color: white;
padding: 30px;
border-radius: 10px;
box-shadow: 0 0 15px rgba(0, 0, 0, 0.1);
}
h1 {
text-align: center;
color: #333;
margin-bottom: 30px;
}
h2 {
font-size: 1.5rem;
margin-bottom: 15px;
color: #444;
}
p {
margin-bottom: 20px;
color: #666;
}
.canvas-container {
margin-bottom: 30px;
text-align: center;
}
canvas {
border: 1px solid #ccc;
background-color: #f9f9f9;
}
.manual-input {
margin-bottom: 25px;
}
.coordinates-container {
max-height: 200px;
overflow-y: auto;
margin-bottom: 15px;
}
.coordinate-pair {
display: flex;
margin-bottom: 8px;
align-items: center;
}
input {
width: 80px;
padding: 8px;
margin-right: 10px;
border: 1px solid #ccc;
border-radius: 4px;
}
button {
padding: 8px 15px;
background-color: #4CAF50;
color: white;
border: none;
border-radius: 4px;
cursor: pointer;
transition: background-color 0.3s;
}
button:hover {
background-color: #45a049;
}
.remove-point {
background-color: #f44336;
padding: 8px 12px;
}
.remove-point:hover {
background-color: #d32f2f;
}
#clear-canvas {
margin-top: 10px;
}
.units-selection {
margin-bottom: 25px;
}
select {
padding: 8px;
border: 1px solid #ccc;
border-radius: 4px;
}
.results-section {
margin-top: 30px;
padding: 20px;
background-color: #f0f8ff;
border-radius: 6px;
display: none;
}
.results-section.active {
display: block;
}
.area-result {
font-size: 1.3rem;
margin-bottom: 15px;
}
.calculation-steps {
margin-top: 20px;
padding: 15px;
background-color: #f5f5f5;
border-radius: 4px;
font-family: monospace;
}Implementazione di JavaScript
Now, let's create the script.js file that will power our geometry area calculator:
// DOM Elements
const canvas = document.getElementById('polygon-canvas');
const ctx = canvas.getContext('2d');
const clearCanvasBtn = document.getElementById('clear-canvas');
const addPointBtn = document.getElementById('add-point');
const coordinatesList = document.getElementById('coordinates-list');
const calculateBtn = document.getElementById('calculate-area');
const resultsSection = document.getElementById('results');
const unitsSelect = document.getElementById('units');
// Global Variables
let points = [];
let isDragging = false;
let dragIndex = -1;
// Canvas Setup
function setupCanvas() {
// Set canvas coordinate system (origin at center)
ctx.translate(canvas.width / 2, canvas.height / 2);
drawGrid();
// Event listeners for canvas interaction
canvas.addEventListener('mousedown', handleMouseDown);
canvas.addEventListener('mousemove', handleMouseMove);
canvas.addEventListener('mouseup', () => isDragging = false);
// Redraw canvas initially
redrawCanvas();
}
// Draw coordinate grid
function drawGrid() {
const width = canvas.width;
const height = canvas.height;
ctx.strokeStyle = '#e0e0e0';
ctx.lineWidth = 1;
// Vertical lines
for (let x = -width/2; x <= width/2; x += 20) {
ctx.beginPath();
ctx.moveTo(x, -height/2);
ctx.lineTo(x, height/2);
ctx.stroke();
}
// Horizontal lines
for (let y = -height/2; y <= height/2; y += 20) {
ctx.beginPath();
ctx.moveTo(-width/2, y);
ctx.lineTo(width/2, y);
ctx.stroke();
}
// X and Y axes (darker)
ctx.strokeStyle = '#aaa';
ctx.lineWidth = 2;
// X-axis
ctx.beginPath();
ctx.moveTo(-width/2, 0);
ctx.lineTo(width/2, 0);
ctx.stroke();
// Y-axis
ctx.beginPath();
ctx.moveTo(0, -height/2);
ctx.lineTo(0, height/2);
ctx.stroke();
}
// Handle mouse down event on canvas
function handleMouseDown(e) {
const rect = canvas.getBoundingClientRect();
const scaleX = canvas.width / rect.width;
const scaleY = canvas.height / rect.height;
const canvasX = (e.clientX - rect.left) * scaleX - canvas.width / 2;
const canvasY = (e.clientY - rect.top) * scaleY - canvas.height / 2;
// Check if clicking near an existing point (for dragging)
for (let i = 0; i < points.length; i++) {
const dx = points[i].x - canvasX;
const dy = points[i].y - canvasY;
const distance = Math.sqrt(dx * dx + dy * dy);
if (distance < 10) {
isDragging = true;
dragIndex = i;
return;
}
}
// If not dragging, add a new point
points.push({x: canvasX, y: canvasY});
updateCoordinateInputs();
redrawCanvas();
}
// Handle mouse move event on canvas
function handleMouseMove(e) {
if (!isDragging || dragIndex === -1) return;
const rect = canvas.getBoundingClientRect();
const scaleX = canvas.width / rect.width;
const scaleY = canvas.height / rect.height;
const canvasX = (e.clientX - rect.left) * scaleX - canvas.width / 2;
const canvasY = (e.clientY - rect.top) * scaleY - canvas.height / 2;
points[dragIndex] = {x: canvasX, y: canvasY};
updateCoordinateInputs();
redrawCanvas();
}
// Redraw the canvas with all points and connections
function redrawCanvas() {
// Clear the canvas
ctx.clearRect(-canvas.width/2, -canvas.height/2, canvas.width, canvas.height);
// Redraw the grid
drawGrid();
if (points.length === 0) return;
// Draw the polygon
ctx.beginPath();
ctx.moveTo(points[0].x, points[0].y);
for (let i = 1; i < points.length; i++) {
ctx.lineTo(points[i].x, points[i].y);
}
// Connect back to the first point if we have at least 3 points
if (points.length >= 3) {
ctx.lineTo(points[0].x, points[0].y);
// Fill the polygon with a semi-transparent color
ctx.fillStyle = 'rgba(76, 175, 80, 0.2)';
ctx.fill();
}
// Draw the polygon outline
ctx.strokeStyle = '#4CAF50';
ctx.lineWidth = 2;
ctx.stroke();
// Draw the points
for (let i = 0; i < points.length; i++) {
ctx.beginPath();
ctx.arc(points[i].x, points[i].y, 5, 0, Math.PI * 2);
ctx.fillStyle = '#4CAF50';
ctx.fill();
// Label the points
ctx.fillStyle = '#333';
ctx.font = '12px Arial';
ctx.fillText(`P${i+1}`, points[i].x + 8, points[i].y - 8);
}
}
// Update the coordinate inputs based on canvas points
function updateCoordinateInputs() {
// Clear all existing inputs
coordinatesList.innerHTML = '';
// Add new inputs for each point
for (let i = 0; i < points.length; i++) {
const pair = document.createElement('div');
pair.className = 'coordinate-pair';
const xInput = document.createElement('input');
xInput.type = 'number';
xInput.className = 'x-coord';
xInput.placeholder = `X${i+1}`;
xInput.value = Math.round(points[i].x);
xInput.dataset.index = i;
const yInput = document.createElement('input');
yInput.type = 'number';
yInput.className = 'y-coord';
yInput.placeholder = `Y${i+1}`;
yInput.value = Math.round(points[i].y);
yInput.dataset.index = i;
const removeBtn = document.createElement('button');
removeBtn.className = 'remove-point';
removeBtn.textContent = '×';
removeBtn.dataset.index = i;
pair.appendChild(xInput);
pair.appendChild(yInput);
pair.appendChild(removeBtn);
coordinatesList.appendChild(pair);
// Event listeners for manual input changes
xInput.addEventListener('change', updatePointFromInput);
yInput.addEventListener('change', updatePointFromInput);
removeBtn.addEventListener('click', removePoint);
}
}
// Update a point from manual input
function updatePointFromInput(e) {
const index = parseInt(e.target.dataset.index);
const value = parseFloat(e.target.value);
if (isNaN(value)) return;
if (e.target.className === 'x-coord') {
points[index].x = value;
} else {
points[index].y = value;
}
redrawCanvas();
}
// Remove a point
function removePoint(e) {
const index = parseInt(e.target.dataset.index);
points.splice(index, 1);
updateCoordinateInputs();
redrawCanvas();
}
// Add a new point via button
function addNewPoint() {
// Add a new point at (0, 0) or near the last point if one exists
if (points.length > 0) {
const lastPoint = points[points.length - 1];
points.push({x: lastPoint.x + 20, y: lastPoint.y + 20});
} else {
points.push({x: 0, y: 0});
}
updateCoordinateInputs();
redrawCanvas();
}
// Clear all points
function clearCanvas() {
points = [];
updateCoordinateInputs();
redrawCanvas();
resultsSection.style.display = 'none';
}
// Calculate area using the Shoelace formula
function calculatePolygonArea(vertices) {
if (vertices.length < 3) return 0;
let area = 0;
const n = vertices.length;
for (let i = 0; i < n; i++) {
const j = (i + 1) % n;
area += vertices[i].x * vertices[j].y;
area -= vertices[j].x * vertices[i].y;
}
return Math.abs(area / 2);
}
// Display the calculation results
function displayResults() {
if (points.length < 3) {
alert("You need at least 3 points to calculate area.");
return;
}
const area = calculatePolygonArea(points);
const selectedUnit = unitsSelect.value;
let unitSymbol = 'px²';
let convertedArea = area;
// Apply unit conversions if needed
if (selectedUnit === 'meters') {
unitSymbol = 'm²';
// Assuming 1 pixel = 0.01 meter for example
convertedArea = area * 0.0001;
} else if (selectedUnit === 'feet') {
unitSymbol = 'ft²';
// Assuming 1 pixel = 0.0328 feet
convertedArea = area * 0.001;
}
// Format the result
const formattedArea = convertedArea.toFixed(2);
// Create the result HTML
let resultHTML = `
<h2>Calculation Results</h2>
<div class="area-result">
<strong>Polygon Area:</strong> ${formattedArea} ${unitSymbol}
</div>
<p>Based on ${points.length} vertices</p>
<div class="calculation-steps">
<h3>Calculation Steps:</h3>
<p>Using the Shoelace formula: A = 0.5 × |∑(xᵢyᵢ₊₁ − xᵢ₊₁yᵢ)|</p>
<ol>
`;
// Add the calculation steps
for (let i = 0; i < points.length; i++) {
const j = (i + 1) % points.length;
const term = (points[i].x * points[j].y - points[j].x * points[i].y).toFixed(2);
resultHTML += `<li>Step ${i+1}: (${points[i].x} × ${points[j].y}) - (${points[j].x} × ${points[i].y}) = ${term}</li>`;
}
resultHTML += `
</ol>
<p>Summing all steps and taking absolute value: ${Math.abs(area).toFixed(2)}</p>
<p>Dividing by 2: ${(Math.abs(area)/2).toFixed(2)}</p>
</div>
`;
resultsSection.innerHTML = resultHTML;
resultsSection.style.display = 'block';
resultsSection.scrollIntoView({ behavior: 'smooth' });
}
// Initialize the application
function init() {
setupCanvas();
// Event listeners
clearCanvasBtn.addEventListener('click', clearCanvas);
addPointBtn.addEventListener('click', addNewPoint);
calculateBtn.addEventListener('click', displayResults);
}
// Start the app when the page loads
window.addEventListener('load', init);
Rappresentazione visiva di come la formula della scarpa calcola l'area di un poligono
Comprendere i componenti chiave
Abbattiamo i principali componenti del nostro calcolatore dell'area di geometria:
Interazione in tela
Il nostro calcolatore utilizza un elemento di tela HTML per la creazione di poligoni interattiva.Gli utenti possono:
- Fare clic sulla tela per aggiungere punti
- Trascina i punti esistenti per regolare le posizioni
- Vedere la visualizzazione in tempo reale del poligono
- Visualizza una griglia di coordinate per riferimento
La tela è impostata con un sistema di coordinate in cui (0,0) è al centro, rendendo intuitivo per gli utenti lavorare con coordinate sia positive che negative.
Coordinare la gestione deiput
Gli utenti possono inserire coordinate in due modi:
- Input visivo: fare clic direttamente sulla tela per posizionare i punti
- Input manuale: immettere le coordinate esatte nei campi di input
I due metodi di input sono sincronizzati, consentendo sia il posizionamento visivo intuitivo sia un input numerico preciso.
L'implementazione dell'algoritmo Shoelace
Il nucleo del nostro calcolatore è l'implementazione della formula per la scarina:
function calculatePolygonArea(vertices) {
if (vertices.length < 3) return 0;
let area = 0;
const n = vertices.length;
for (let i = 0; i < n; i++) {
const j = (i + 1) % n;
area += vertices[i].x * vertices[j].y;
area -= vertices[j].x * vertices[i].y;
}
return Math.abs(area / 2);
}Questa funzione:
- Prende una matrice di coordinate di vertice
- Luci attraverso ogni punto e il punto successivo (avvolgendo al primo punto)
- Applica il calcolo del prodotto incrociato
- Prende il valore assoluto e si divide per 2 per ottenere l'area finale
La bellezza di questo algoritmo è che funziona per qualsiasi poligono, indipendentemente dal fatto che sia convesso o concavo, purché non si interseca.
Aggiunta di funzionalità avanzate
Ora che abbiamo il calcolatore di base che funziona, estendiamolo con alcune funzionalità avanzate:
Conversione dell'unità
Il nostro calcolatore supporta diverse unità di misurazione:
- Pixel: per le misurazioni basate sullo schermo
- Metri: per le misurazioni metriche del mondo reale
- Piedi: per le misurazioni imperiali
La conversione dell'unità viene applicata dopo il calcolo dell'area:
// Apply unit conversions if needed
if (selectedUnit === 'meters') {
unitSymbol = 'm²';
// Assuming 1 pixel = 0.01 meter for example
convertedArea = area * 0.0001;
} else if (selectedUnit === 'feet') {
unitSymbol = 'ft²';
// Assuming 1 pixel = 0.0328 feet
convertedArea = area * 0.001;
}Puoi personalizzare i fattori di conversione in base ai requisiti specifici.
L'interfaccia calcolatrice che mostra le opzioni di conversione dell'unità per diversi sistemi di misurazione
Passaggi di calcolo dettagliati
Per aiutare gli utenti a capire come viene calcolata l'area, forniamo una rottura dettagliata delle fasi di calcolo:
// Add the calculation steps
for (let i = 0; i < points.length; i++) {
const j = (i + 1) % points.length;
const term = (points[i].x * points[j].y - points[j].x * points[i].y).toFixed(2);
resultHTML += `<li>Step ${i+1}: (${points[i].x} × ${points[j].y}) - (${points[j].x} × ${points[i].y}) = ${term}</li>`;
}Questa trasparenza aiuta gli utenti a verificare i risultati e conoscere i principi matematici alla base dei calcoli dell'area di Polygon.
Test e validazione
Prima di considerare il nostro calcolatore di geometria completa, testalo con alcune forme note per verificarne la precisione:
Caso di prova 1: rettangolo
Un semplice rettangolo con vertici a (0,0), (100,0), (100,50) e (0,50) dovrebbe avere un'area di 5.000 unità quadrate.
Caso di prova 2: Triangolo
Un triangolo con vertici a (0,0), (50.100) e (100,0) dovrebbe avere un'area di 5.000 unità quadrate.
Caso di prova 3: poligono irregolare
Un poligono irregolare con vertici a (0,0), (50.100), (100,50), (75,25) e (25,25) dovrebbe darci l'area corretta in base alla formula della Shoelace.
Per ogni caso di test, il nostro calcolatore dovrebbe:
- Consentire un semplice input delle coordinate del test
- Calcola l'area corretta
- Visualizza i passaggi di calcolo per la verifica
Ottimizzazione per dispositivi mobili
Per rendere pienamente reattiva il nostro calcolatore di geometria, possiamo aggiungere i seguenti miglioramenti:
- Toccare il supporto per l'interazione in tela
- Layout reattivo che si adatta a diverse dimensioni dello schermo
- Interfaccia semplificata per schermi più piccoli
Queste aggiunte assicurano che il nostro calcolatore sia utilizzabile su smartphone e tablet, rendendolo accessibile agli utenti su tutti i dispositivi.
Ulteriori miglioramenti
Per rendere la nostra calcolatrice dell'area di geometria ancora più robusta, prendi in considerazione l'implementazione di queste caratteristiche aggiuntive:
Forme preimpostate
Aggiungi pulsanti per creare rapidamente forme comuni come:
- Piazza
- Rettangolo
- Triangolo
- Cerchio (approssimato come un normale poligono)
- Poligoni regolari (Pentagono, esagono, ecc.)
Calcolo dell'area per cerchi
Estendere il calcolatore per gestire le aree del cerchio usando:
function calculateCircleArea(radius) {
return Math.PI * radius * radius;
}Calcolo del perimetro
Aggiungi funzionalità per calcolare il perimetro dei poligoni:
function calculatePolygonPerimeter(vertices) {
let perimeter = 0;
const n = vertices.length;
for (let i = 0; i < n; i++) {
const j = (i + 1) % n;
const dx = vertices[j].x - vertices[i].x;
const dy = vertices[j].y - vertices[i].y;
perimeter += Math.sqrt(dx * dx + dy * dy);
}
return perimeter;
}Salvare e caricare poligoni
Implementare LocalStorage per salvare e caricare le configurazioni di poligono:
// Save polygon
function savePolygon(name) {
const polygonData = JSON.stringify(points);
localStorage.setItem(`polygon_${name}`, polygonData);
}
// Load polygon
function loadPolygon(name) {
const polygonData = localStorage.getItem(`polygon_${name}`);
if (polygonData) {
points = JSON.parse(polygonData);
updateCoordinateInputs();
redrawCanvas();
}
}Applicazioni pratiche
Varie applicazioni del mondo reale in cui i calcolatori dell'area di geometria forniscono soluzioni preziose
Il nostro calcolatore dell'area di geometria JavaScript ha numerose applicazioni pratiche:
Sviluppo web
- Mappe interattive e visualizzazioni di trama
- Applicazioni di rilevamento della terra
- Strumenti di pianificazione immobiliare
- Layout della stanza e applicazioni di progettazione
Istruzione
- Insegnare i principi geometrici in modo interattivo
- Visualizzazione di concetti matematici
- Creazione di risorse di apprendimento interattive
Sviluppo del gioco
- Rilevamento delle collisioni per oggetti di gioco
- Design di livello e creazione dell'ambiente
- Generazione procedurale di mondi di gioco
Conclusione
In questo tutorial completo, abbiamo costruito un potente calcolatore di area di geometria interattiva usando JavaScript.Il nostro calcolatore può:
- Calcola accuratamente l'area di qualsiasi poligono usando la formula per la scarina
- Fornire un'interfaccia visiva intuitiva per la creazione e la modifica delle forme
- Supportare l'input di coordinate manuali per misurazioni precise
- Converti tra diverse unità di misurazione
- Mostra passaggi di calcolo dettagliati a fini educativi
I principi e le tecniche che abbiamo trattato - geometria coordinata, algoritmo Shoelace, manipolazione della tela e design dell'interfaccia utente - sono preziose competenze che vanno oltre questo specifico progetto.Puoi applicarli a varie sfide di sviluppo web, dalla visualizzazione dei dati alle applicazioni interattive.
Costruendo questo calcolatore di geometria, non solo hai creato uno strumento utile, ma hai anche approfondito la tua comprensione dei concetti matematici e la loro implementazione in JavaScript.Sentiti libero di estendere il calcolatore con funzionalità aggiuntive, ottimizzare le sue prestazioni o integrarlo nei tuoi progetti.
Codice felice!