ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಿನಾಂಕಗಳನ್ನು ಹೇಗೆ ಹೋಲಿಸುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಿನಾಂಕ ಹೋಲಿಕೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ದಿನಾಂಕಗಳನ್ನು ಹೋಲಿಸುವುದು ಸಾಮಾನ್ಯ ಅವಶ್ಯಕತೆಯಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಪಠ್ಯ ಪೆಟ್ಟಿಗೆಗಳಿಂದ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸುವಾಗ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದಿನಾಂಕಗಳನ್ನು ಹೋಲಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಡೆವಲಪರ್‌ಗಳಿಗೆ ಒಂದು ದಿನಾಂಕವು ಇನ್ನೊಂದು ದಿನಾಂಕಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಹಿಂದಿನದಕ್ಕಿಂತ ದೊಡ್ಡದಾಗಿದೆ, ಕಡಿಮೆಯಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಈ ಲೇಖನವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಿನಾಂಕ ಮೌಲ್ಯಗಳನ್ನು ಹೋಲಿಸಲು ವಿವಿಧ ವಿಧಾನಗಳ ಮೂಲಕ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ, ನಿಖರವಾದ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮೌಲ್ಯೀಕರಣವನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ನೀವು ಬುಕಿಂಗ್ ಸಿಸ್ಟಮ್, ಈವೆಂಟ್ ಪ್ಲಾನರ್ ಅಥವಾ ದಿನಾಂಕ ಹೋಲಿಕೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಯಾವುದೇ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೀರಿ, ಈ ತಂತ್ರಗಳು ಅಮೂಲ್ಯವಾಗಿರುತ್ತವೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಿನಾಂಕ ಹೋಲಿಕೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಮುಂಭಾಗದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪಠ್ಯ ಪೆಟ್ಟಿಗೆಗಳ ಮೂಲಕ ಬಳಕೆದಾರರು ಎರಡು ದಿನಾಂಕಗಳ ಇನ್‌ಪುಟ್ ಅನ್ನು ಹೋಲಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ದಿ new Date() ಸ್ಟ್ರಿಂಗ್ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ದಿನಾಂಕ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಲು ಆಜ್ಞೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ದಿ document.getElementById() ಪಠ್ಯ ಪೆಟ್ಟಿಗೆಗಳಿಂದ ಮೌಲ್ಯಗಳನ್ನು ಅವುಗಳ ID ಗಳಿಂದ ಹಿಂಪಡೆಯಲು ಆಜ್ಞೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ದಿನಾಂಕಗಳನ್ನು ಹಿಂಪಡೆದ ನಂತರ ಮತ್ತು ಪರಿವರ್ತಿಸಿದ ನಂತರ, ಸ್ಕ್ರಿಪ್ಟ್ ಸರಳ ಹೋಲಿಕೆ ಆಪರೇಟರ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಒಂದು ದಿನಾಂಕವು ಇನ್ನೊಂದು ದಿನಾಂಕಕ್ಕಿಂತ ಹೆಚ್ಚಿದೆಯೇ, ಕಡಿಮೆಯಾಗಿದೆಯೇ ಅಥವಾ ಸಮಾನವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪ್ರಸ್ತುತ ದಿನಾಂಕವನ್ನು ಬಳಸಿಕೊಂಡು ಪಡೆಯಲಾಗುತ್ತದೆ new Date() ಮತ್ತು ಇನ್‌ಪುಟ್ ದಿನಾಂಕಗಳಿಗೆ ಹೋಲಿಸಿದರೆ ಅವು ಹಿಂದೆ ಇದ್ದವು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು. ಈ ಹೋಲಿಕೆಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ನಂತರ ಎಚ್ಚರಿಕೆ ಸಂದೇಶಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಬಳಕೆದಾರರಿಗೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

ಸರ್ವರ್ ಬದಿಯಲ್ಲಿ ದಿನಾಂಕ ಹೋಲಿಕೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬ್ಯಾಕೆಂಡ್ ಸ್ಕ್ರಿಪ್ಟ್ ಎಕ್ಸ್‌ಪ್ರೆಸ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ನೊಂದಿಗೆ Node.js ಅನ್ನು ಬಳಸುತ್ತದೆ. ಎಕ್ಸ್‌ಪ್ರೆಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ ಮತ್ತು ಒಳಬರುವ JSON ವಿನಂತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪಾರ್ಸಿಂಗ್ ಮಾಡುವ ಮೂಲಕ ಇದು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ express.json(). ಮಾರ್ಗ app.post() POST ವಿನಂತಿಗಳನ್ನು / ಹೋಲಿಸಿ-ದಿನಾಂಕಗಳ ಅಂತಿಮ ಬಿಂದುವಿಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ಮಾರ್ಗದಲ್ಲಿ, ದಿನಾಂಕಗಳನ್ನು ವಿನಂತಿಯ ದೇಹದಿಂದ ಹೊರತೆಗೆಯಲಾಗುತ್ತದೆ, ಬಳಸಿ ದಿನಾಂಕದ ವಸ್ತುಗಳಿಗೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ new Date(), ಮತ್ತು ಮುಂಭಾಗದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಇದೇ ರೀತಿಯಲ್ಲಿ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಈ ಹೋಲಿಕೆಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಒಂದೇ ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಲೈಂಟ್‌ಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ res.send(). ನಂತರ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪೋರ್ಟ್ 3000 ಬಳಸಿ ಒಳಬರುವ ಸಂಪರ್ಕಗಳನ್ನು ಕೇಳುತ್ತದೆ app.listen().

// Get date values from text boxes
function compareDates() {
  const date1 = new Date(document.getElementById('date1').value);
  const date2 = new Date(document.getElementById('date2').value);
  const now = new Date();
  if (date1 > date2) {
    alert('Date 1 is greater than Date 2');
  } else if (date1 < date2) {
    alert('Date 1 is less than Date 2');
  } else {
    alert('Date 1 is equal to Date 2');
  }
  if (date1 < now) {
    alert('Date 1 is in the past');
  }
  if (date2 < now) {
    alert('Date 2 is in the past');
  }
}

const express = require('express');
const app = express();
app.use(express.json());
app.post('/compare-dates', (req, res) => {
  const { date1, date2 } = req.body;
  const d1 = new Date(date1);
  const d2 = new Date(date2);
  const now = new Date();
  let result = '';
  if (d1 > d2) {
    result += 'Date 1 is greater than Date 2. ';
  } else if (d1 < d2) {
    result += 'Date 1 is less than Date 2. ';
  } else {
    result += 'Date 1 is equal to Date 2. ';
  }
  if (d1 < now) {
    result += 'Date 1 is in the past. ';
  }
  if (d2 < now) {
    result += 'Date 2 is in the past.';
  }
  res.send(result);
});
app.listen(3000, () => console.log('Server running on port 3000'));

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸುಧಾರಿತ ದಿನಾಂಕ ಹೋಲಿಕೆಗಳನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ

ಮೂಲಭೂತ ದಿನಾಂಕ ಹೋಲಿಕೆಗಳ ಜೊತೆಗೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೆಚ್ಚು ಸುಧಾರಿತ ತಂತ್ರಗಳನ್ನು ಮತ್ತು ಲೈಬ್ರರಿಗಳನ್ನು ನೀಡುತ್ತದೆ ಅದು ದಿನಾಂಕದ ಕುಶಲತೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ. ಅಂತಹ ಒಂದು ಲೈಬ್ರರಿ Moment.js ಆಗಿದೆ, ಇದು ದಿನಾಂಕಗಳನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡಲು, ಮೌಲ್ಯೀಕರಿಸಲು, ಮ್ಯಾನಿಪುಲೇಟ್ ಮಾಡಲು ಮತ್ತು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ಶ್ರೀಮಂತ API ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. Moment.js ದಿನಾಂಕದ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ಎಡ್ಜ್ ಕೇಸ್‌ಗಳು ಮತ್ತು ಸಂಕೀರ್ಣತೆಗಳನ್ನು ನಿಭಾಯಿಸಬಲ್ಲದು, ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಜನಪ್ರಿಯ ಆಯ್ಕೆಯಾಗಿದೆ. Moment.js ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ದಿನಾಂಕಗಳನ್ನು ಸುಲಭವಾಗಿ ವಿಧಾನಗಳೊಂದಿಗೆ ಹೋಲಿಸಬಹುದು isBefore(), isAfter(), ಮತ್ತು isSame(). ಈ ವಿಧಾನಗಳು ಓದುವಿಕೆಯನ್ನು ವರ್ಧಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ದೋಷಗಳ ಸಂಭಾವ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಿನಾಂಕ ಹೋಲಿಕೆಗಾಗಿ ಮತ್ತೊಂದು ಪ್ರಬಲ ಸಾಧನವಾಗಿದೆ Intl.DateTimeFormat ಆಬ್ಜೆಕ್ಟ್, ಇದು ಲೊಕೇಲ್-ಸೆನ್ಸಿಟಿವ್ ರೀತಿಯಲ್ಲಿ ದಿನಾಂಕವನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ದಿನಾಂಕ ಸ್ವರೂಪಗಳು ಬದಲಾಗುವ ಅಂತಾರಾಷ್ಟ್ರೀಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ. ಇದಲ್ಲದೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಂತರ್ನಿರ್ಮಿತ Date ವಸ್ತುವು ಅಂತಹ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ getTime() ಮತ್ತು valueOf() ಇದು ಯುನಿಕ್ಸ್ ಯುಗದಿಂದ ಮಿಲಿಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ದಿನಾಂಕಗಳನ್ನು ಸಂಖ್ಯಾತ್ಮಕವಾಗಿ ಹೋಲಿಸಲು ನೇರವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ದಿನಾಂಕ ಹೋಲಿಕೆಗಳಿಗಾಗಿ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸುವಂತಹ ತಂತ್ರಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟ ಈ ವಿಧಾನಗಳು ನಿಮ್ಮ ಕೋಡ್‌ನ ದೃಢತೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚಿಸಬಹುದು.

JavaScript ನಲ್ಲಿ ದಿನಾಂಕ ಹೋಲಿಕೆ ತಂತ್ರಗಳ ಸಾರಾಂಶ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಿನಾಂಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಅವುಗಳನ್ನು ನಿಖರವಾಗಿ ಹೋಲಿಸುವುದು ವಿವಿಧ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ದಿನಾಂಕದ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು, ಡೆವಲಪರ್‌ಗಳು ದಿನಾಂಕದ ತಂತಿಗಳನ್ನು ಹೋಲಿಸಬಹುದಾದ ವಸ್ತುಗಳನ್ನಾಗಿ ಸುಲಭವಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು. > ಮತ್ತು < ನಂತಹ ಸರಳ ಹೋಲಿಕೆ ನಿರ್ವಾಹಕರು ಒಂದು ದಿನಾಂಕವು ಇನ್ನೊಂದಕ್ಕಿಂತ ದೊಡ್ಡದಾಗಿದೆ ಅಥವಾ ಕಡಿಮೆಯಾಗಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸಬಹುದು. Moment.js ನಂತಹ ಸುಧಾರಿತ ಸಾಧನಗಳು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಸನ್ನಿವೇಶಗಳಿಗಾಗಿ isBefore() ಮತ್ತು isAfter() ನಂತಹ ವಿಧಾನಗಳನ್ನು ನೀಡುತ್ತವೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, Node.js ನೊಂದಿಗೆ ಬ್ಯಾಕೆಂಡ್‌ನಲ್ಲಿ ದಿನಾಂಕ ಹೋಲಿಕೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿವಿಧ ಭಾಗಗಳಲ್ಲಿ ದಿನಾಂಕದ ಮಾಹಿತಿಯ ಸ್ಥಿರವಾದ ಮೌಲ್ಯೀಕರಣ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.