ஜாவாஸ்கிரிப்ட் செயல்பாட்டிலிருந்து தசமங்களை நீக்குதல்: ஒரு எளிய வழிகாட்டி

JavaScript செயல்பாடுகளில் தசம சிக்கல்களைக் கையாளுதல்

ஜாவாஸ்கிரிப்ட் செயல்பாடுகளை எழுதும்போது, ​​தசம எண்கள் தொடர்பான சிக்கல்களை எதிர்கொள்வது பொதுவானது, குறிப்பாக பிரிவு செயல்பாடுகளைச் செய்யும்போது. ஒரு சுத்தமான மற்றும் முழு எண் வெளியீட்டாக தேவைப்படும் டெவலப்பர்களுக்கு, இந்த தசம முடிவுகளை எவ்வாறு நிர்வகிப்பது என்பதைப் புரிந்துகொள்வது அவசியம்.

இந்த வழிகாட்டியில், ஆரம்ப கணக்கீடு தசமங்களை உள்ளடக்கியதா என்பதைப் பொருட்படுத்தாமல், திரும்ப மதிப்பு முழு எண்ணாக இருப்பதை உறுதிசெய்ய, JavaScript செயல்பாட்டை எவ்வாறு மாற்றுவது என்பதை ஆராய்வோம். விகிதங்கள் அல்லது சராசரிகளை நிர்ணயிப்பது போன்ற கணக்கீடுகளை உள்ளடக்கிய செயல்பாடுகளுடன் பணிபுரியும் போது இது பல தொடக்கநிலையாளர்கள் எதிர்கொள்ளும் சவாலாகும்.

முழு எண் முடிவை உருவாக்காத எண்களைப் பிரிப்பதில் இருந்து பெரும்பாலும் சிக்கல் ஏற்படுகிறது. உதாரணமாக, ஒரு கல்வியாளருக்கான மாணவர்களின் சராசரியைக் கணக்கிடுவது ஒரு தசமத்தை அளிக்கலாம், இது சில சூழல்களில் விரும்பப்படாமல் இருக்கலாம். வெளியீட்டின் வாசிப்புத்திறன் மற்றும் பயன்பாட்டினை மேம்படுத்துவதற்கான பொதுவான பணியாக இந்த தசமங்களை அகற்றுவது அல்லது ரவுண்டிங் செய்வது.

ஜாவாஸ்கிரிப்ட்டின் உள்ளமைக்கப்பட்ட கணித செயல்பாடுகளை எவ்வாறு பயன்படுத்துவது என்பது போன்ற செயல்முறையை நாங்கள் மேற்கொள்வோம் Math.round(), Math.floor(), மற்றும் Math.ceil(), தசமங்களை நீக்கி முழு எண்ணை வழங்கவும். இதன் முடிவில், உங்கள் குறிப்பிட்ட தேவைகளைப் பூர்த்தி செய்ய உங்கள் செயல்பாட்டின் வருவாயை எவ்வாறு வடிவமைப்பது என்பதை நீங்கள் புரிந்துகொள்வீர்கள்.

தசமங்களை அகற்றுவதற்கான ஜாவாஸ்கிரிப்ட் முறைகளைப் புரிந்துகொள்வது

ஜாவாஸ்கிரிப்ட் செயல்பாடுகளை கையாளும் போது, ​​தசமங்களை வழங்கும் மாணவர்கள் பெர்அட்மின் செயல்பாடு, முழு எண்களைப் பெற முடிவுகளை எவ்வாறு மாற்றுவது என்பதைப் புரிந்துகொள்வது அவசியம். இந்தச் செயல்பாட்டில், மாணவர்களின் எண்ணிக்கையை ஆசிரியர்கள் மற்றும் உதவியாளர்களின் கூட்டுத்தொகையால் வகுப்பதன் மூலம் ஒரு கல்வியாளருக்கு சராசரி மாணவர்களின் எண்ணிக்கை கணக்கிடப்படுகிறது. இருப்பினும், பிரிவு பெரும்பாலும் தசம மதிப்புகளில் விளைவதால், இந்த முடிவுகளைக் கையாள பல்வேறு கணித முறைகள் தேவைப்படுகின்றன. ஒரு ஆசிரியருக்கு எத்தனை மாணவர்கள் ஒதுக்கப்படுகிறார்கள் என்பதைப் புகாரளிப்பது போன்ற ஒரு முழு எண் மட்டுமே பயனுள்ளதாக இருக்கும் சூழலுக்கு ஏற்றவாறு தசமப் பகுதியைச் சுற்றி அல்லது துண்டிப்பதே சவாலாகும்.

எடுத்துக்காட்டில் பயன்படுத்தப்படும் முதல் அணுகுமுறை Math.round(). இந்த முறை தசம எண்ணை அருகில் உள்ள முழு எண்ணுடன் சுற்றுகிறது. உதாரணமாக, சராசரி 13.666 என்றால், கணிதம்.சுற்று தசமம் 0.5 ஐ விட அதிகமாக இருப்பதால் 14 ஐ வழங்கும். எண்ணை எளிதாக்கும் போது நீங்கள் துல்லியத்தை பராமரிக்க விரும்பும் சந்தர்ப்பங்களில் இந்த முறை பயனுள்ளதாக இருக்கும். மற்றொரு அணுகுமுறை Math.floor(), இது எப்போதும் எண்ணைக் குறைக்கும். தசம மதிப்பைப் பொருட்படுத்தாமல், அதே எடுத்துக்காட்டில் 13 ஐத் திரும்பப் பெறுவது போன்ற தசம பகுதியை முழுவதுமாக நிராகரிக்க விரும்பினால் இது பயன்படுத்தப்படும்.

மறுபுறம், Math.ceil() என்ற எதிர் நோக்கத்திற்கு உதவுகிறது Math.floor(), எப்பொழுதும் எண்ணை அருகில் உள்ள முழு எண்ணாக ரவுண்டிங் செய்யும். முழு எண் பகுதியை விட மதிப்பு குறைவாக இல்லை என்பதை உறுதிப்படுத்த விரும்பினால் இந்த முறை சிறந்தது. உதாரணமாக, சராசரி 13.1 என்றால், Math.ceil() தசம பகுதி மிகச் சிறியதாக இருந்தாலும், 14ஐத் தரும். இந்த முறைகள் உங்கள் கணக்கீட்டின் குறிப்பிட்ட தேவைகளைப் பொறுத்து நெகிழ்வுத்தன்மையை அனுமதிக்கின்றன. இலக்கு அருகில் உள்ளதைச் சுற்றினாலோ, ரவுண்ட் டவுன் செய்தாலோ அல்லது ரவுண்ட்அப் செய்தாலோ, ஒவ்வொரு செயல்பாடும் தனித்தனியான நோக்கத்திற்கு உதவுகிறது.

கூடுதலாக, பயன்பாடு assert.strictEqual() யூனிட் சோதனைகளில் செயல்பாடுகள் எதிர்பார்த்தபடி செயல்படுவதை உறுதி செய்கிறது. உங்கள் செயல்பாட்டின் வெளியீடு பல்வேறு சோதனை நிகழ்வுகளில் எதிர்பார்த்த முடிவுடன் பொருந்துகிறதா என்பதைச் சரிபார்க்க இந்தக் கட்டளை முக்கியமானது. இது ஒரு பாதுகாப்பாக செயல்படுகிறது, டெவலப்பர்கள் தங்கள் மாற்றங்கள் செயல்பாட்டை உடைக்கிறதா இல்லையா என்பதை விரைவாகச் சரிபார்க்க அனுமதிக்கிறது. இணைந்து தேவை() தேவையான தொகுதிகளை இறக்குமதி செய்ய, இந்த சோதனைகள் கூடுதல் சரிபார்ப்பு அடுக்கு சேர்க்கின்றன, உற்பத்தி சூழல்களில் குறியீட்டின் நம்பகத்தன்மையை உறுதி செய்கிறது. இந்த நுட்பங்களைச் சேர்ப்பதன் மூலம், குறியீடு துல்லியமானது மட்டுமல்ல, முற்றிலும் சோதிக்கப்பட்டு வெவ்வேறு பயன்பாட்டுக் காட்சிகளுக்குத் தயாராக உள்ளது.

// 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!');

சிக்கலான ஜாவாஸ்கிரிப்ட் காட்சிகளில் தசமங்களைக் கையாளுதல்

தசமங்களை வட்டமிடுவது JavaScript இல் பொதுவான தேவையாக இருந்தாலும், தசம இடங்களை நிர்வகிப்பதற்கு அதிக கட்டுப்பாடு தேவைப்படும் பிற காட்சிகளும் உள்ளன. மிக முக்கியமான நுட்பங்களில் ஒன்று வேலை செய்கிறது நிலையான(). இந்த முறை நீங்கள் எத்தனை தசம இடங்களை விரும்புகிறீர்கள் என்பதைக் குறிப்பிட அனுமதிக்கிறது, அதே நேரத்தில் ஒரு நிலையான காட்சி வடிவமைப்பை உறுதிசெய்யும் போது எண்ணை அருகிலுள்ள மதிப்பிற்குச் சுற்றுகிறது. உதாரணமாக, number.toFixed(2) நாணயக் கணக்கீடுகள் அல்லது அறிவியல் அளவீடுகள் போன்ற துல்லியம் முக்கியத்துவம் வாய்ந்த சூழ்நிலைகளுக்கு எப்போதும் இரண்டு தசம இடங்களைக் கொண்ட எண்ணை வழங்கும்.

ஜாவாஸ்கிரிப்ட் மிதக்கும் புள்ளி எண்கணிதத்தை எவ்வாறு கையாளுகிறது என்பது மற்றொரு முக்கியமான கருத்து. நினைவகத்தில் எண்கள் சேமிக்கப்படும் விதம் காரணமாக, தசமங்களில் செயல்பாடுகள் சில நேரங்களில் எதிர்பாராத முடிவுகளுக்கு வழிவகுக்கும், குறிப்பாக இரண்டு மிதக்கும் புள்ளி எண்களை ஒப்பிடும் போது. உதாரணமாக, 0.1 + 0.2 சரியாக சமமாக இல்லை 0.3 ஜாவாஸ்கிரிப்டில், சில கணக்கீடுகளில் சிக்கல்களை ஏற்படுத்தலாம். இந்த நுணுக்கங்களைப் புரிந்துகொள்வது உங்கள் குறியீட்டில் உள்ள பிழைகளைத் தவிர்க்க உதவும், குறிப்பாக நிதி அல்லது புள்ளிவிவரக் கணக்கீடுகளைக் கையாளும் போது.

மேலும், நீங்கள் வட்டமிடாமல் தசமங்களை முழுவதுமாக அகற்ற வேண்டும் என்றால், நீங்கள் பிட்வைஸ் ஆபரேட்டர்களைப் பயன்படுத்தலாம் ~~ (இரட்டை டில்டே), இது ஒரு எண்ணின் தசம பகுதியை திறம்பட துண்டிக்கிறது. பிட்வைஸ் ஆபரேட்டர்கள் செயல்பாட்டில் எண்ணை முழு எண்ணாக மாற்றுவதால் இந்த அணுகுமுறை செயல்படுகிறது. உதாரணமாக, ~~13.666 முடிவு ~~13.99. இந்த முறை குறைவாகவே பயன்படுத்தப்படுகிறது, ஆனால் செயல்திறன் முக்கியமானதாக இருக்கும்போது தசமங்களைக் குறைக்கும் இலக்கை அடைய விரைவான வழியை வழங்குகிறது.