Ta bort decimaler från JavaScript Funktion Return: A Simple Guide

Hantera decimalproblem i JavaScript-funktioner

När du skriver JavaScript-funktioner är det vanligt att stöta på problem relaterade till decimaltal, särskilt när du utför divisionsoperationer. För utvecklare som behöver ett rent och heltal som utdata är det viktigt att förstå hur man hanterar dessa decimalresultat.

I den här guiden kommer vi att utforska hur man ändrar en JavaScript-funktion för att säkerställa att returvärdet är ett heltal, oavsett om den initiala beräkningen innefattar decimaler. Detta är en utmaning som många nybörjare möter när de arbetar med funktioner som involverar beräkningar, som att bestämma kvoter eller medelvärden.

Problemet beror ofta på att dela tal som inte ger ett heltalsresultat. Att beräkna genomsnittet av elever per pedagog kan till exempel returnera en decimal, vilket kanske inte är önskvärt i vissa sammanhang. Att ta bort eller avrunda dessa decimaler är en vanlig uppgift för att förbättra utdatas läsbarhet och användbarhet.

Vi kommer att gå igenom processen för hur man använder JavaScripts inbyggda matematiska funktioner, som t.ex Math.round(), Math.floor(), och Math.ceil(), för att ta bort decimaler och returnera ett heltal. I slutet av detta kommer du att förstå hur du formaterar din funktions retur för att möta dina specifika behov.

Förstå JavaScript-metoder för att ta bort decimaler

När det gäller JavaScript-funktioner som returnerar decimaler, som i studenter Per Admin funktion är det viktigt att förstå hur man modifierar resultaten för att få heltal. I denna funktion beräknas det genomsnittliga antalet elever per pedagog genom att dividera antalet elever med summan av lärare och medhjälpare. Men eftersom division ofta resulterar i decimalvärden behövs olika matematiska metoder för att hantera dessa resultat. Utmaningen är att avrunda eller trunkera decimaldelen för att passa sammanhanget där endast ett heltal är användbart, som att rapportera hur många elever som tilldelas per lärare.

Det första tillvägagångssättet som används i exemplet är Math.round(). Denna metod avrundar decimaltalet till närmaste heltal. Till exempel, om genomsnittet är 13,666, Math.round returnerar 14 eftersom decimaltalet är större än 0,5. Den här metoden är användbar i fall där du vill bibehålla noggrannheten samtidigt som du förenklar numret. Ett annat tillvägagångssätt är Math.floor(), vilket alltid avrundar siffran nedåt. Det används när du vill kassera decimaldelen helt, till exempel returnera 13 i samma exempel, oavsett decimalvärdet.

Å andra sidan, Math.ceil() tjänar det motsatta syftet Math.floor(), alltid avrunda talet uppåt till närmaste heltal. Denna metod är idealisk när du vill säkerställa att värdet aldrig är lägre än heltalsdelen. Till exempel, om genomsnittet är 13,1, Math.ceil() kommer att returnera 14, även om decimaldelen är ganska liten. Dessa metoder tillåter flexibilitet beroende på de specifika behoven i din beräkning. Oavsett om målet är att avrunda till närmaste, avrunda nedåt eller avrunda uppåt, tjänar varje funktion ett distinkt syfte.

Dessutom kan användningen av assert.strictEqual() i enhetstesterna säkerställer att funktionerna fungerar som förväntat. Detta kommando är viktigt för att kontrollera om utdata från din funktion matchar det förväntade resultatet i olika testfall. Det fungerar som ett skydd, vilket gör att utvecklare snabbt kan verifiera om deras ändringar bryter funktionen eller inte. I kombination med behöva() för att importera nödvändiga moduler lägger dessa test till ett extra lager av validering, vilket säkerställer tillförlitligheten hos koden i produktionsmiljöer. Genom att införliva dessa tekniker är koden inte bara korrekt utan också noggrant testad och redo för olika användningsscenarier.

// Solution 1: Using Math.round() to round to the nearest integer
function studentsPerAdmin(students, teachers, helpers) {
  const average = students / (teachers + helpers);
  const roundedAverage = Math.round(average);
  if (roundedAverage > 10) {
    console.log(`There are on average ${roundedAverage} students for each educator.`);
  } else {
    console.log('Unfortunately this class will be cancelled due to not having enough students enrolled.');
  }
  return roundedAverage;
}
studentsPerAdmin(41, 1, 2); // Result: 14 students for each educator

// Solution 2: Using Math.floor() to always round down
function studentsPerAdmin(students, teachers, helpers) {
  const average = students / (teachers + helpers);
  const flooredAverage = Math.floor(average);
  if (flooredAverage > 10) {
    console.log(`There are on average ${flooredAverage} students for each educator.`);
  } else {
    console.log('Unfortunately this class will be cancelled due to not having enough students enrolled.');
  }
  return flooredAverage;
}
studentsPerAdmin(41, 1, 2); // Result: 13 students for each educator

// Solution 3: Using Math.ceil() to always round up
function studentsPerAdmin(students, teachers, helpers) {
  const average = students / (teachers + helpers);
  const ceiledAverage = Math.ceil(average);
  if (ceiledAverage > 10) {
    console.log(`There are on average ${ceiledAverage} students for each educator.`);
  } else {
    console.log('Unfortunately this class will be cancelled due to not having enough students enrolled.');
  }
  return ceiledAverage;
}
studentsPerAdmin(41, 1, 2); // Result: 14 students for each educator

// Unit Test for verifying all solutions
const assert = require('assert');
assert.strictEqual(studentsPerAdmin(41, 1, 2), 14);  // Using Math.round()
assert.strictEqual(studentsPerAdmin(30, 1, 2), 10);  // Using Math.floor()
assert.strictEqual(studentsPerAdmin(35, 1, 2), 12);  // Using Math.ceil()
console.log('All tests passed!');

Hantera decimaler i komplexa JavaScript-scenarier

Även om avrundning av decimaler är ett vanligt behov i JavaScript, finns det andra scenarier där hantering av decimaler kräver mer kontroll. En av de viktigaste teknikerna är att arbeta med toFixed(). Med den här metoden kan du ange hur många decimaler du vill ha, avrunda talet till närmaste värde samtidigt som du säkerställer ett konsekvent visningsformat. Till exempel, number.toFixed(2) kommer alltid att returnera ett tal med två decimaler, vilket gör det idealiskt för situationer där precision är viktig, som valutaberäkningar eller vetenskapliga mätningar.

Ett annat viktigt koncept är hur JavaScript hanterar aritmetik med flyttal. På grund av hur siffror lagras i minnet kan operationer på decimaler ibland leda till oväntade resultat, särskilt när man jämför två flyttal. Till exempel, 0.1 + 0.2 inte exakt lika 0.3 i JavaScript, vilket kan orsaka problem i vissa beräkningar. Att förstå dessa nyanser kan hjälpa dig att undvika fel i din kod, särskilt när du hanterar finansiella eller statistiska beräkningar.

Dessutom, om du behöver ta bort decimaler helt utan avrundning, kan du använda bitvisa operatorer som ~~ (dubbel tilde), som effektivt trunkerar decimaldelen av ett tal. Detta tillvägagångssätt fungerar eftersom bitvisa operatorer konverterar talet till ett heltal i processen. Till exempel, ~~13.666 resulterar i ~~13.99. Denna metod är mindre vanligt förekommande men ger ett snabbt sätt att uppnå målet att trunkera decimaler när prestanda är avgörande.