ஜாவாஸ்கிரிப்ட்டில்

Ethan Guerin

வியாழன், 20 ஜூன், 2024 ’அன்று’ முற்பகல் 7:50:44

ஜாவாஸ்கிரிப்ட் ரவுண்டிங் மூலம் துல்லியமான மாஸ்டரிங்

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

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

கட்டளை	விளக்கம்
Math.round()	ஒரு எண்ணை அருகிலுள்ள முழு எண்ணுடன் முழுமைப்படுத்துகிறது.
num * 100	தசம புள்ளியை இரண்டு இடங்களை வலப்புறமாக மாற்ற எண்ணை 100 ஆல் பெருக்குகிறது.
/ 100	எண்ணை 100 ஆல் வகுத்து, தசமப் புள்ளியை இடதுபுறமாக இரண்டு இடங்களுக்கு மாற்ற, விரும்பிய துல்லியத்தை அடைகிறது.
require('express')	இணைய சேவையகத்தை அமைக்க Express.js நூலகத்தை உள்ளடக்கியது.
app.get()	குறிப்பிட்ட இறுதிப்புள்ளிக்கான GET கோரிக்கைகளுக்கான வழி கையாளுதலை வரையறுக்கிறது.
parseFloat()	ஒரு சரத்தை பாகுபடுத்தி, மிதக்கும் புள்ளி எண்ணை வழங்கும்.
app.listen()	சேவையகத்தைத் தொடங்கி, உள்வரும் கோரிக்கைகளுக்கு குறிப்பிட்ட போர்ட்டில் கேட்கிறது.

ஜாவாஸ்கிரிப்ட் ரவுண்டிங் ஸ்கிரிப்ட்களைப் புரிந்துகொள்வது

வழங்கப்பட்ட ஸ்கிரிப்டுகள், உங்கள் ஜாவாஸ்கிரிப்ட் பயன்பாடுகளில் துல்லியம் மற்றும் வாசிப்புத்திறனை உறுதி செய்யும் வகையில், ஒரு எண்ணை அதிகபட்சம் இரண்டு தசம இடங்களுக்குச் சுற்றும் வகையில் வடிவமைக்கப்பட்டுள்ளன. முகப்பு உதாரணத்தில், செயல்பாடு roundToTwo(num) பயன்படுத்துகிறது Math.round() முறை. இந்த முறையானது எண்ணை அருகில் உள்ள முழு எண்ணுக்குச் சுற்றுகிறது. வட்டமிடுவதற்கு முன் உள்ளீட்டு எண்ணை 100 ஆல் பெருக்குவதன் மூலம், தசம புள்ளியை இரண்டு இடங்களை வலப்புறமாக மாற்றுவோம். வட்டமிட்ட பிறகு, தசம புள்ளியை பின்னோக்கி மாற்ற, இரண்டு தசம இடங்கள் வரை விரும்பிய துல்லியத்தை அடைய, முடிவை 100 ஆல் வகுக்கிறோம். இந்த அணுகுமுறை தேவைப்பட்டால் மட்டுமே செயல்பாடு தசம இடங்களைச் சேர்ப்பதை உறுதிசெய்கிறது, வெளியீட்டை சுத்தமாகவும், மேலும் பயனர்-நட்பாகவும் ஆக்குகிறது.

Express உடன் Node.js ஐப் பயன்படுத்தி பின்தளத்தில் உள்ள எடுத்துக்காட்டில், ரவுண்டிங் கோரிக்கைகளைக் கையாள ஒரு வலை சேவையகத்தை அமைத்துள்ளோம். தி require('express') கட்டளை Express.js நூலகத்தை உள்ளடக்கியது, இது சர்வர் அமைப்பை எளிதாக்குகிறது. தி app.get('/round/:number', ...) குறிப்பிட்ட இறுதிப்புள்ளியில் GET கோரிக்கைகளை வழி கையாளுபவர் கேட்கிறார். பாதை URL இலிருந்து எண்ணைப் பிரித்தெடுத்து, அதைப் பயன்படுத்தி மிதக்கும் புள்ளி எண்ணாகப் பாகுபடுத்துகிறது parseFloat(), பின்னர் அதையே பயன்படுத்தி வட்டமிடுகிறது roundToTwo() செயல்பாடு. சேவையகம் வட்டமான எண்ணுடன் பதிலளிக்கிறது, பயனர்கள் இந்த செயல்பாட்டை இணைய இடைமுகம் வழியாக அணுக அனுமதிக்கிறது. தி app.listen(port, ...) கட்டளை சேவையகத்தைத் தொடங்குகிறது, உள்வரும் கோரிக்கைகளுக்குக் கிடைக்கும். வலைப் பயன்பாடுகளில் துல்லியமான ரவுண்டிங் செயல்பாட்டை ஒருங்கிணைப்பதற்கும், வெவ்வேறு சூழல்களில் நிலையான தரவு வடிவமைப்பை உறுதி செய்வதற்கும் இந்த அமைப்பு பயனுள்ளதாக இருக்கும்.

ஜாவாஸ்கிரிப்டில் ரவுண்டிங்கைச் செயல்படுத்துதல்

ஜாவாஸ்கிரிப்ட்: முன்பக்கம் உதாரணம்

// Function to round a number to at most 2 decimal places
function roundToTwo(num) {
  return Math.round(num * 100) / 100;
}

// Examples
const num1 = 101.777777;
const num2 = 9.1;

console.log(roundToTwo(num1)); // Output: 101.78
console.log(roundToTwo(num2)); // Output: 9.1

சர்வர்-சைட் ரவுண்டிங் எடுத்துக்காட்டு

Node.js: பின்தள உதாரணம்

const express = require('express');
const app = express();
const port = 3000;

// Function to round a number to at most 2 decimal places
function roundToTwo(num) {
  return Math.round(num * 100) / 100;
}

app.get('/round/:number', (req, res) => {
  const num = parseFloat(req.params.number);
  const roundedNum = roundToTwo(num);
  res.send(`Rounded Number: ${roundedNum}`);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ஜாவாஸ்கிரிப்டில் எண்களை வட்டமிடுவதற்கான மேம்பட்ட நுட்பங்கள்

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

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

JavaScript இல் ரவுண்டிங் பற்றிய பொதுவான கேள்விகள்

ஜாவாஸ்கிரிப்ட்டில் ஒரு எண்ணை 2 தசம இடங்களுக்கு எப்படிச் சுற்றுவது?
நீங்கள் பயன்படுத்தலாம் Math.round(num * 100) / 100 அல்லது num.toFixed(2) ஒரு எண்ணை இரண்டு தசம இடங்களுக்குச் சுற்றுவது.
என்ன வித்தியாசம் Math.round() மற்றும் toFixed()?
Math.round() அருகில் உள்ள முழு எண்ணுக்கு சுற்றுகள், அதே நேரத்தில் toFixed() குறிப்பிட்ட எண்ணிக்கையிலான தசம இடங்களைக் கொண்ட ஒரு எண்ணை ஒரு சரமாக மாற்றுகிறது.
இரண்டு தசம இடங்களுக்கு மேல் எண்களை வட்டமிட முடியுமா?
ஆம், நீங்கள் அதே முறைகளைப் பயன்படுத்தலாம் மற்றும் விரும்பிய எண்ணிக்கையிலான தசம இடங்களைக் குறிப்பிடலாம், எ.கா., num.toFixed(3) மூன்று தசம இடங்களுக்கு.
ஜாவாஸ்கிரிப்ட்டில் நான் ஏன் ரவுண்டிங் பிழைகளை அடைகிறேன்?
ஜாவாஸ்கிரிப்ட் மிதக்கும்-புள்ளி எண்கணிதத்தைக் கையாளும் விதத்தின் காரணமாக ரவுண்டிங் பிழைகள் ஏற்படுகின்றன, இது சிறிய தவறுகளுக்கு வழிவகுக்கும்.
ரவுண்டிங் பிழைகளை நான் எவ்வாறு தவிர்க்கலாம்?
போன்ற நூலகங்களைப் பயன்படுத்துதல் Decimal.js துல்லியமான எண்கணித செயல்பாடுகளை வழங்குவதன் மூலம் ரவுண்டிங் பிழைகளைத் தவிர்க்க உதவும்.
இருக்கிறது toFixed() நிதி கணக்கீடுகளுக்கு ஏற்றதா?
toFixed() நிலையான தசம இடங்களைக் கொண்ட எண்களைக் காண்பிக்க பயனுள்ளதாக இருக்கும், ஆனால் துல்லியமான கணக்கீடுகளுக்கு, சிறப்பு நூலகங்களைப் பயன்படுத்துவதைக் கவனியுங்கள்.
ஜாவாஸ்கிரிப்டில் துல்லியமான எண்கணிதத்திற்கான சில பொதுவான நூலகங்கள் யாவை?
பொதுவான நூலகங்கள் அடங்கும் Decimal.js, Big.js, மற்றும் Math.js.
ஜாவாஸ்கிரிப்ட் முன்னோட்டம் மற்றும் பின்தளம் இரண்டிலும் நான் ரவுண்டிங் செயல்பாடுகளைப் பயன்படுத்தலாமா?
ஆம், அதே ரவுண்டிங் செயல்பாடுகளை முன்பக்கம் மற்றும் பின்தளத்தில் JavaScript சூழல்கள் இரண்டிலும் பயன்படுத்தலாம்.
ஒரு எண்ணை அருகில் உள்ள முழு எண்ணுக்கு எப்படி சுற்றுவது?
நீங்கள் பயன்படுத்தலாம் Math.round() ஒரு எண்ணை அருகிலுள்ள முழு எண்ணுக்குச் சுற்றும் செயல்பாடு.

ஜாவாஸ்கிரிப்ட் ரவுண்டிங் டெக்னிக்குகளின் சுருக்கம்

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

மேம்பட்ட ஜாவாஸ்கிரிப்ட் ரவுண்டிங் முறைகள்

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

JavaScript இல் ரவுண்டிங் பற்றிய இறுதி எண்ணங்கள்

ஜாவாஸ்கிரிப்டில் ரவுண்டிங் நுட்பங்களை மாஸ்டரிங் செய்வது, எண் தரவுகளைத் துல்லியமாகக் கையாளும் வலுவான பயன்பாடுகளை உருவாக்குவதற்கு அவசியம். போன்ற முறைகளைப் பயன்படுத்துவதன் மூலம் Math.round மற்றும் toFixed, மற்றும் போன்ற நூலகங்களை இணைத்தல் Decimal.js, நீங்கள் துல்லியத்தை உறுதிசெய்து, மிதக்கும் புள்ளி எண்கணிதத்துடன் தொடர்புடைய பொதுவான ஆபத்துக்களைத் தவிர்க்கலாம். நம்பகமான மற்றும் பயனர் நட்பு தரவு விளக்கக்காட்சிகளை வழங்கும் பயன்பாடுகளை உருவாக்க இந்த நடைமுறைகள் இன்றியமையாதவை.

ஜாவாஸ்கிரிப்ட்டில் அதிகபட்சம் இரண்டு தசம இடங்களுக்கு எண்களை முழுமைப்படுத்துதல்