Node.js API ಇಮೇಲ್ ಪಡೆಯುವಿಕೆ: ಬಗೆಹರಿಯದ ಪ್ರತಿಕ್ರಿಯೆಗಳು

API ಪ್ರತಿಕ್ರಿಯೆ ಸಮಸ್ಯೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

Node.js ನಲ್ಲಿ ಇಮೇಲ್ ಪ್ರಸರಣಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸರಳವಾದ ಸರ್ವರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ನೀವು ಅನಿರೀಕ್ಷಿತ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಬಹುದು, ಅಲ್ಲಿ ಪಡೆಯುವ API ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ. ಅಸಮಕಾಲಿಕ ವಿನಂತಿಯಿಂದ JSON ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವಾಗ ಈ ದೋಷ ಸಂಭವಿಸುತ್ತದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ "ವ್ಯಾಖ್ಯಾನಿಸದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಓದಲಾಗುವುದಿಲ್ಲ ('json'' ಓದುವಿಕೆ')" ಸಂದೇಶದಿಂದ ಹೈಲೈಟ್ ಮಾಡಲಾಗಿದೆ. ಈ ಸಮಸ್ಯೆಯು ಗೊಂದಲಮಯವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಒಂದೇ ರೀತಿಯ ಕೋಡ್ ಬೇರೆ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

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

Node.js ಸರ್ವರ್ ಮತ್ತು ಫೆಚ್ ಮೆಥಡಾಲಜಿಯನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ

ಮೇಲೆ ವಿವರಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು Node.js ಸರ್ವರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಇಮೇಲ್‌ಗಳನ್ನು ಕಳುಹಿಸಲು ಬ್ಯಾಕೆಂಡ್ ಮತ್ತು ಮುಂಭಾಗದ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಬ್ಯಾಕೆಂಡ್ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುತ್ತದೆ ವ್ಯಕ್ತಪಡಿಸಿ ಸರ್ವರ್ ಅನ್ನು ಹೊಂದಿಸಲು ಮತ್ತು ಇಮೇಲ್ ಡೇಟಾಕ್ಕಾಗಿ POST ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮಾಡ್ಯೂಲ್. ಇದು ಬಳಸುತ್ತದೆ ದೇಹದ ಪಾರ್ಸರ್ ಒಳಬರುವ ವಿನಂತಿಯ ದೇಹಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ಮತ್ತು ತರಲು ಇಮೇಲ್ ರವಾನೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಬಾಹ್ಯ API ಗೆ POST ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಲು. ಈ ಆಜ್ಞೆಗಳು ಸರ್ವರ್ ಇಮೇಲ್ ಡೇಟಾವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸ್ವೀಕರಿಸಬಹುದು, ಪಾರ್ಸ್ ಮಾಡಬಹುದು ಮತ್ತು ಫಾರ್ವರ್ಡ್ ಮಾಡಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ದಿ Promise.race() ಸಮಯ ಮೀರುವಿಕೆಗಳು ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಕಾರ್ಯವು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಇದು ಸಮಯ ಮೀರುವ ಭರವಸೆಯ ವಿರುದ್ಧ ಪಡೆದುಕೊಳ್ಳುವ ವಿನಂತಿಯನ್ನು ಸ್ಪರ್ಧಿಸುತ್ತದೆ, ಸ್ಪಂದಿಸುವಿಕೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿಧಾನವಾದ ನೆಟ್‌ವರ್ಕ್ ಪ್ರತಿಕ್ರಿಯೆಗಳಲ್ಲಿ ಸ್ಥಗಿತಗೊಳ್ಳುವುದನ್ನು ಸರ್ವರ್ ತಡೆಯಲು ಯಾವುದು ಮೊದಲು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆಯೋ ಅದನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಪಡೆಯುವ ಭರವಸೆಯು ಮೊದಲು ಪರಿಹರಿಸಿದರೆ, ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದು ಯಶಸ್ವಿಯಾದರೆ, ಪ್ರತಿಕ್ರಿಯೆ ಡೇಟಾವನ್ನು ಪಾರ್ಸ್ ಮಾಡಲಾಗುತ್ತದೆ response.json(). ಕಾಲಾವಧಿ ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ದೋಷದಂತಹ ಯಾವುದೇ ಹಂತವು ವಿಫಲವಾದಲ್ಲಿ, ಸಿಸ್ಟಮ್ ಮತ್ತು ಸಂಭಾವ್ಯ ಬಳಕೆದಾರರಿಗೆ ತಿಳಿಸಲು ಸೂಕ್ತವಾದ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಒದಗಿಸಲಾಗುತ್ತದೆ.

Node.js ಇಮೇಲ್ API ನಲ್ಲಿ ವಿವರಿಸಲಾಗದ JSON ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತಿದೆ

ದೋಷ ನಿರ್ವಹಣೆ ಸುಧಾರಣೆಗಳೊಂದಿಗೆ Node.js

const express = require('express');
const bodyParser = require('body-parser');
const fetch = require('node-fetch');
const app = express();
app.use(bodyParser.json());

const timeout = () => new Promise((_, reject) => setTimeout(() => reject(new Error('Request timed out')), 5000));

async function useFetch(url, emailData) {
  try {
    const response = await Promise.race([
      fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(emailData)
      }),
      timeout()
    ]);
    if (!response) throw new Error('No response from fetch');
    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
    return await response.json();
  } catch (error) {
    console.error('Fetch Error:', error.message);
    throw error;
  }
}

app.post('/sendEmail', async (req, res) => {
  try {
    const result = await useFetch('http://example.com/send', req.body);
    res.status(200).send({ status: 'Email sent successfully', data: result });
  } catch (error) {
    res.status(500).send({ error: error.message });
  }
});

app.listen(3000, () => console.log('Server running on port 3000'));

Node.js ಇಮೇಲ್ ಕಳುಹಿಸುವಿಕೆಗಾಗಿ ಮುಂಭಾಗದ ನಿರ್ವಹಣೆ

ಅಸಮಕಾಲಿಕ ವಿನಂತಿ ನಿರ್ವಹಣೆಯೊಂದಿಗೆ JavaScript

document.getElementById('sendButton').addEventListener('click', sendEmail);

async function sendEmail() {
  const emailData = {
    recipient: document.getElementById('email').value,
    subject: document.getElementById('subject').value,
    message: document.getElementById('message').value
  };
  try {
    const response = await fetch('/sendEmail', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(emailData)
    });
    if (!response.ok) throw new Error('Failed to send email');
    const result = await response.json();
    console.log('Email sent:', result);
    alert('Email sent successfully!');
  } catch (error) {
    console.error('Error sending email:', error);
    alert(error.message);
  }
}

Node.js ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು API ಸಂವಹನದ ಒಳನೋಟಗಳು

Node.js ನಲ್ಲಿ ಸರ್ವರ್-ಸೈಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ, ವಿಶೇಷವಾಗಿ ಇಮೇಲ್ ಕಳುಹಿಸುವಂತಹ ಬಾಹ್ಯ API ಸಂವಹನಗಳನ್ನು ಒಳಗೊಂಡಿರುವಾಗ, ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಇದು ನಿಮ್ಮ ಸರ್ವರ್ ಆಕರ್ಷಕವಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ ಮತ್ತು ದೋಷಗಳಿಂದ ಚೇತರಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಆದರೆ ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಒಟ್ಟಾರೆ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳಂತಹ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿನ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವುದರಿಂದ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್ ಆಗುವುದನ್ನು ತಡೆಯಬಹುದು ಮತ್ತು ಏನು ತಪ್ಪಾಗಿದೆ ಎಂಬುದರ ಕುರಿತು ಬಳಕೆದಾರರಿಗೆ ಉಪಯುಕ್ತ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡುತ್ತದೆ.

ಭರವಸೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಸರಿಯಾಗಿ ಅನುಷ್ಠಾನಗೊಳಿಸುವುದು ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳು Node.js ನಲ್ಲಿ ಮೂಲಭೂತವಾಗಿವೆ. ನಂತಹ ರಚನೆಗಳನ್ನು ಹೇಗೆ ಬಳಸಬೇಕೆಂದು ತಿಳಿಯುವುದು ಇದರಲ್ಲಿ ಸೇರಿದೆ Promise.race() ಬಹು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು, ನಿಮಗೆ ಸಮಯ ಮೀರುವಿಕೆಯಂತಹ ಫಾಲ್‌ಬ್ಯಾಕ್ ಕಾರ್ಯವಿಧಾನದ ಅಗತ್ಯವಿರುವಾಗ ನಿರ್ಣಾಯಕವಾಗಬಹುದು, ಬಾಹ್ಯ ಸೇವೆಗಳು ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ವಿಳಂಬಿಸಿದಾಗ ಅಥವಾ ಪ್ರತಿಕ್ರಿಯಿಸಲು ವಿಫಲವಾದಾಗಲೂ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಸ್ಪಂದಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು.

Node.js ಇಮೇಲ್ API ದೋಷಗಳ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಗಳು

1. ಪ್ರಶ್ನೆ: Node.js ನಲ್ಲಿ fetch ಅನ್ನು ಬಳಸುವಾಗ ನಾನು 'ಅನಿರ್ದಿಷ್ಟ' ದೋಷವನ್ನು ಏಕೆ ಪಡೆಯುತ್ತಿದ್ದೇನೆ?
2. ಉತ್ತರ: ಪ್ರತಿಕ್ರಿಯೆ ವಸ್ತುವನ್ನು ಸರಿಯಾಗಿ ಹಿಂತಿರುಗಿಸದಿದ್ದಾಗ ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಭವಿಸುತ್ತದೆ, ಬಹುಶಃ ನೆಟ್‌ವರ್ಕ್ ಸಮಸ್ಯೆಗಳು ಅಥವಾ ಅಸಮಕಾಲಿಕ ಕೋಡ್‌ನ ತಪ್ಪಾದ ನಿರ್ವಹಣೆಯಿಂದಾಗಿ.
3. ಪ್ರಶ್ನೆ: ಪಡೆದುಕೊಳ್ಳುವಿಕೆಯನ್ನು ಬಳಸುವಾಗ ನಾನು Node.js ನಲ್ಲಿ ಸಮಯ ಮೀರುವಿಕೆಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬಹುದು?
4. ಉತ್ತರ: ಬಳಸಿಕೊಂಡು ಸಮಯ ಮೀರುವ ಕಾರ್ಯವಿಧಾನವನ್ನು ಅಳವಡಿಸಿ Promise.race() ಸಮಯ ಮೀರುವ ಭರವಸೆ ಮತ್ತು ತರಲು ವಿನಂತಿಯೊಂದಿಗೆ. ಪಡೆದುಕೊಳ್ಳಲು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಂಡರೆ, ಸಮಯ ಮೀರುವ ಭರವಸೆಯು ಮೊದಲು ತಿರಸ್ಕರಿಸುತ್ತದೆ, ಪರಿಸ್ಥಿತಿಯನ್ನು ನಿಭಾಯಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ.
5. ಪ್ರಶ್ನೆ: 'ಪಡೆಯಲು ವಿಫಲವಾಗಿದೆ' ನೊಂದಿಗೆ ತರಲು ವಿಫಲವಾದರೆ ನಾನು ಏನು ಮಾಡಬೇಕು?
6. ಉತ್ತರ: ಈ ದೋಷವು ಸಾಮಾನ್ಯವಾಗಿ ನೆಟ್‌ವರ್ಕ್ ಸಮಸ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನಿಮ್ಮ ಸರ್ವರ್ ಇಂಟರ್ನೆಟ್ ಅನ್ನು ತಲುಪಬಹುದೆಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ದೋಷಗಳಿಗಾಗಿ ಯಾವುದೇ URL ಗಳು ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಿ.
7. ಪ್ರಶ್ನೆ: ನನ್ನ API ವಿಭಿನ್ನ HTTP ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಥಿತಿಗಳನ್ನು ಸರಿಯಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ ಎಂದು ನಾನು ಹೇಗೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು?
8. ಉತ್ತರ: ಪರಿಶೀಲಿಸಿ ಪ್ರತಿಕ್ರಿಯೆ. ಸರಿ ಕರೆ ತರುವ ನಂತರ ಆಸ್ತಿ. ಇದು ತಪ್ಪಾಗಿದ್ದರೆ, ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಥಿತಿ ಕೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಮತ್ತು ವಿಭಿನ್ನ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮೂಲಕ ಅದನ್ನು ನಿರ್ವಹಿಸಿ.
9. ಪ್ರಶ್ನೆ: ಅಸಮಕಾಲಿಕ Node.js ಕಾರ್ಯಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಉತ್ತಮ ಮಾರ್ಗ ಯಾವುದು?
10. ಉತ್ತರ: ನಿಮ್ಮ ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಅನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಕನ್ಸೋಲ್ ಲಾಗಿಂಗ್ ಅನ್ನು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಿ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಹೆಚ್ಚು ವಿವರವಾದ ದೋಷ ಸ್ಟಾಕ್ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುವ Node.js ನಲ್ಲಿ ಅಸಿಂಕ್ ಸ್ಟಾಕ್ ಟ್ರೇಸ್ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

Node.js ನಲ್ಲಿ ಪಡೆಯುವ ದೋಷಗಳನ್ನು ನಿಭಾಯಿಸುವ ಕುರಿತು ಅಂತಿಮ ಆಲೋಚನೆಗಳು

Node.js ನಲ್ಲಿ ಪಡೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಪರಿಶೋಧನೆಯ ಉದ್ದಕ್ಕೂ, ಅಸಮಕಾಲಿಕ ದೋಷಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ವಿಶ್ವಾಸಾರ್ಹ ಸರ್ವರ್-ಸೈಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಮುಖವಾಗಿದೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿದೆ. Promise.race ನೊಂದಿಗೆ ಸಮಯಾವಧಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯ ಸಿಂಧುತ್ವವನ್ನು ಪರಿಶೀಲಿಸುವಂತಹ ತಂತ್ರಗಳು ಬಾಹ್ಯ ಸೇವೆಗಳೊಂದಿಗೆ ಸಂವಹನದಲ್ಲಿನ ಸ್ಥಗಿತಗಳ ವಿರುದ್ಧ ರಕ್ಷಿಸುವಲ್ಲಿ ನಿರ್ಣಾಯಕ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತವೆ. ಈ ವಿಧಾನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮತ್ತು ಅನ್ವಯಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ತಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಕ್ರಿಯಾತ್ಮಕವಾಗಿರುವುದನ್ನು ಮಾತ್ರವಲ್ಲದೆ ವೈಫಲ್ಯಗಳ ಮುಖಾಂತರ ಚೇತರಿಸಿಕೊಳ್ಳುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.