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

Isanes Francois

சனி, 5 அக்டோபர், 2024 ’அன்று’ முற்பகல் 2:54:45

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

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

வெளிப்புற API இலிருந்து தரவை மீட்டெடுக்கும் செயல்பாட்டை அழைப்பதில் சிக்கல் உள்ளது. இந்த குறிப்பிட்ட சிக்கல் செயல்பாட்டு அழைப்பில் மாறிகள் சரியாக அறிவிக்கப்படாததால் உருவாகிறது. சரியாகக் கையாளப்படாவிட்டால், இது உங்கள் குறியீட்டை உடைக்கக்கூடும்.

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

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

கட்டளை	பயன்பாட்டின் உதாரணம்
fetch()	தி பெறு() கட்டளை கொடுக்கப்பட்ட URL க்கு பிணைய கோரிக்கையைத் தொடங்குகிறது. இந்த வழக்கில், இது API இலிருந்து மாற்று விகிதங்களைப் பெறுகிறது மற்றும் ஒரு வாக்குறுதியை வழங்குகிறது, இது வெளிப்புற சேவைகளிலிருந்து தரவை மீட்டெடுப்பது போன்ற ஒத்திசைவற்ற பணிகளைச் செய்ய அனுமதிக்கிறது.
then()	தி பின்னர் () முறை நிறைவேற்றப்பட்ட வாக்குறுதியின் பதிலைக் கையாளுகிறது. பிறகு பெறு() API தரவைப் பெறுகிறது, பின்னர் () API ஆல் வழங்கப்பட்ட JSON தரவை செயலாக்குகிறது.
catch()	தி பிடிக்க () பிழைகளை நிர்வகிப்பதற்கான வாக்குறுதி சங்கிலியில் முறை சேர்க்கப்பட்டுள்ளது. இந்த எடுத்துக்காட்டில், நெட்வொர்க் செயலிழப்புகள் அல்லது பிழையான பதில்கள் போன்ற பெறுதல் செயல்பாட்டின் போது ஏற்படும் சிக்கல்களைக் கண்டறிந்து பதிவு செய்கிறது.
axios.get()	Node.js உதாரணம் பயன்படுத்துகிறது axios.get() API இறுதிப் புள்ளிக்கு HTTP GET கோரிக்கையை அனுப்ப. இந்தச் செயல்பாடு HTTP வினவல்களை ஒழுங்குபடுத்துகிறது மற்றும் சர்வரின் தரவுகளுடன் தீர்க்கப்படும் வாக்குறுதியை வழங்குகிறது.
mockResolvedValue()	ஜெஸ்ட் சோதனையில், mockResolvedValue() நடத்தையை கேலி செய்ய பயன்படுகிறது axios`. சோதனை காரணங்களுக்காக, get() ஐப் பயன்படுத்தவும் கட்டுப்படுத்தப்பட்ட பதிலை வழங்க. யூனிட் சோதனைகள் API வெற்றிகரமான சூழ்நிலைகளைப் பின்பற்றுவதை இது உறுதி செய்கிறது.
mockRejectedValue()	போன்றது mockResolvedValue(), தி mockRejectedValue() ஜெஸ்டில் உள்ள முறையானது, நெட்வொர்க் சிக்கல் போன்ற பிழையின் பதிலைப் பிரதிபலிக்கிறது, இது எங்கள் செயல்பாடு தோல்விகளை எவ்வாறு கையாளுகிறது என்பதைச் சோதிக்க அனுமதிக்கிறது.
expect()	எதிர்பார்க்கலாம்() சோதனைகளில் எதிர்பார்த்த முடிவுகளை உறுதிப்படுத்தும் ஒரு ஜெஸ்ட் செயல்பாடு. நிகழ்வுகளில், API கோரிக்கை தோல்வியுற்றால், சரியான விகிதம் திரும்பப் பெறப்படுவதை அல்லது விதிவிலக்கு அளிக்கப்படுவதை இது உறுதி செய்கிறது.
rejects.toThrow()	ஜெஸ்ட் பயன்படுத்துகிறார் நிராகரிக்கிறது.toTthrow() ஒரு வாக்குறுதி ஒரு பிழையைத் தருகிறது என்பதை உறுதிப்படுத்தும் முறை. நிராகரிக்கப்பட்ட API அழைப்பை, போலி நெட்வொர்க் சிக்கல்கள் போன்ற செயல்பாடு எவ்வாறு கையாளுகிறது என்பதை மதிப்பிடும்போது இது மிகவும் பயனுள்ளதாக இருக்கும்.
document.body.innerHTML	DOM கையாளுதல் கட்டளை document.body.innerHTML பக்கத்தில் உள்ள உடல் உறுப்பு உள்ளடக்கத்தை மாற்றியமைக்கிறது. எடுத்துக்காட்டில், பெறப்பட்ட நாணய விகிதம் வலைப்பக்கத்தில் மாறும் வகையில் காட்டப்படும்.

ஜாவாஸ்கிரிப்ட் API அழைப்புகளில் உள்ள குறிப்புப் பிழையைத் தீர்க்கிறது

வழங்கப்பட்ட எடுத்துக்காட்டுகளில், ஜாவாஸ்கிரிப்ட் ஸ்கிரிப்ட்கள் ஒரு API, குறிப்பாக BitPay சேவையிலிருந்து மாற்று விகிதங்களை மீட்டெடுக்கும் நோக்கம் கொண்டவை. முக்கிய பிரச்சினை ஏ குறிப்புப் பிழை பயன்படுத்தும் போது வரையறுக்கப்படாத மாறிகளால் உருவாக்கப்படுகிறது gc() செயல்பாடு. இதை நிவர்த்தி செய்ய, 'eth' மற்றும் 'usd' போன்ற செயல்பாட்டிற்கு வழங்கப்பட்ட அளவுருக்கள் சரங்களாக சரியாக அறிவிக்கப்படுவதை உறுதி செய்வதே முதல் படியாகும். வரையறுக்கப்படாத மாறிகளை ஜாவாஸ்கிரிப்ட் மூலம் செயலாக்க முடியாது, எனவே அவற்றை மேற்கோள்களில் இணைப்பது சிக்கலைத் தீர்க்கிறது மற்றும் பெறுதல் கோரிக்கையை சரியான URL கட்டுமானத்துடன் தொடர அனுமதிக்கிறது.

ஃபெட்ச் ஏபிஐ என்பது இந்த அணுகுமுறையின் ஒரு முக்கிய அங்கமாகும், இது ஸ்கிரிப்ட் வெளிப்புற சர்வரில் இருந்து ஒத்திசைவற்ற முறையில் தரவைப் பெற அனுமதிக்கிறது. இந்த எடுத்துக்காட்டில், get() ஆனது இரண்டு அளவுருக்கள் (var1 மற்றும் var2) மூலம் குறிப்பிடப்பட்ட URL க்கு HTTP கோரிக்கையை அனுப்புகிறது. URL அமைப்பு முக்கியமானது, மேலும் பயனர் உள்ளீட்டின் அடிப்படையில் பொருத்தமான இறுதிப்புள்ளி என்று அதன் மாறும் தலைமுறை உத்தரவாதம் அளிக்கிறது. தரவை மீட்டெடுத்த பிறகு, அதைப் பயன்படுத்தி பாகுபடுத்தப்படுகிறது res.json() பதிலை JSON வடிவத்திற்கு மாற்ற. இதன் விளைவாக வரும் பரிமாற்ற வீதம் DOM மாற்றத்தின் மூலம் HTML உடலில் காட்டப்படும், இது பயனர் இடைமுகத்தை உண்மையான நேரத்தில் புதுப்பிக்கிறது.

Node.js பதிப்பில், நாங்கள் பயன்படுத்துகிறோம் அச்சுகள் பெறுவதற்குப் பதிலாக, பின்தள சூழல்களில் HTTP கோரிக்கைகளைக் கையாளுவதற்கு மிகவும் வலுவான தொகுப்பு. Axios பிழை கையாளுதலை மேம்படுத்துகிறது மற்றும் பதில் பாகுபடுத்தும் செயல்முறையை நெறிப்படுத்துகிறது. ஸ்கிரிப்ட்டில், axios API இறுதிப்புள்ளிக்கு GET கோரிக்கையை உருவாக்குகிறது, தரவைச் சேகரிக்கிறது மற்றும் கன்சோலில் பரிமாற்ற வீதத்தைக் காட்டுகிறது. மேலும், API அழைப்பைச் செய்வதற்கு முன் செயல்பாட்டில் இரண்டு அளவுருக்களும் வழங்கப்படுவதை ஸ்கிரிப்ட் உறுதிசெய்கிறது, இது மற்றொரு சாத்தியமான பிழை மூலத்தை நீக்குகிறது.

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

குறிப்புப் பிழையைத் தீர்க்கிறது: ஜாவாஸ்கிரிப்ட் ஏபிஐ பெறுதலில் மாறிகள் வரையறுக்கப்படவில்லை

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

// Define the function with two parameters
function getRates(var1, var2) {
    // Define the URL with the parameters
    let url = 'https://bitpay.com/rates/' + var1 + '/' + var2;
    // Fetch data from the URL
    fetch(url)
    .then(res => {
        if (!res.ok) throw new Error('Network response was not ok');
        return res.json();
    })
    .then(out => {
        // Update the body with the rate
        document.body.innerHTML = 'Rate: ' + out.data.rate;
    })
    .catch(error => console.error('There was an error:', error));
}
// Correctly call the function with string parameters
getRates('eth', 'usd');

Node.js இல் வரையறுக்கப்படாத மாறிகள் மற்றும் பிழை மேலாண்மை ஆகியவற்றைக் கையாளுதல்

இந்த பின்தள நுட்பம் உள்ளீடு சரிபார்ப்பு மற்றும் பிழை கையாளுதலுடன் API கோரிக்கைக்கான Node.js மற்றும் axios ஐப் பயன்படுத்துகிறது.

const axios = require('axios');
// Function to get exchange rates
function getRates(var1, var2) {
    // Validate input parameters
    if (!var1 || !var2) {
        throw new Error('Both currency parameters must be defined');
    }
    // Define the URL
    const url = 'https://bitpay.com/rates/' + var1 + '/' + var2;
    // Make the request using axios
    axios.get(url)
        .then(response => {
            console.log('Rate:', response.data.data.rate);
        })
        .catch(error => {
            console.error('Error fetching rate:', error.message);
        });
}
// Correctly call the function
getRates('eth', 'usd');

Jest ஐப் பயன்படுத்தி JavaScript இல் getRates செயல்பாட்டைச் சோதிக்கும் அலகு

இந்தச் சோதனை ஸ்கிரிப்ட், வெற்றிகரமான API கோரிக்கைகள் மற்றும் பிழை நிலைமைகள் உட்பட பல்வேறு காட்சிகளைக் கையாளக்கூடியது என்பதை உறுதிப்படுத்த Jest ஐப் பயன்படுத்துகிறது.

const axios = require('axios');
const { getRates } = require('./getRates');
jest.mock('axios');
// Test successful API call
test('should return correct rate', async () => {
    axios.get.mockResolvedValue({ data: { data: { rate: 2500 } } });
    const rate = await getRates('eth', 'usd');
    expect(rate).toBe(2500);
});
// Test API call failure
test('should handle error', async () => {
    axios.get.mockRejectedValue(new Error('Network Error'));
    await expect(getRates('eth', 'usd')).rejects.toThrow('Network Error');
});

ஜாவாஸ்கிரிப்ட் API அழைப்புகளில் மாறி வரையறைகளைக் கையாளுதல்

சரியான மாறி நோக்கம் மற்றும் துவக்கம் ஆகியவை கையாள்வதற்கு முக்கியமானவை குறிப்புப் பிழை JavaScript இல், குறிப்பாக API அழைப்புகளைக் கையாளும் போது. ஜாவாஸ்கிரிப்டில் மாறிகளை சரியாக வரையறுத்து அறிவிக்க, பயன்படுத்தவும் அனுமதிக்க அல்லது நிலையான. பயன்பாட்டிற்கு முன் மாறிகளை அறிவிக்கத் தவறினால், அல்லது அவற்றின் நோக்கத்திற்கு வெளியே அவற்றை அழைப்பது, "குறிப்புப் பிழை: மாறி வரையறுக்கப்படவில்லை" போன்ற பிழைகளை அடிக்கடி விளைவிக்கிறது. ஏபிஐ வினவல்களைச் செய்யும்போது, வாதங்கள் சரியாகத் தொகுக்கப்பட்டிருப்பதை உறுதிசெய்வது முக்கியம்.

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

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

ஜாவாஸ்கிரிப்ட் API அழைப்புப் பிழைகளில் அடிக்கடி கேட்கப்படும் கேள்விகள்

ஜாவாஸ்கிரிப்டில் குறிப்புப் பிழை ஏற்பட என்ன காரணம்?
ஒரு மாறி அது வரையறுக்கப்படுவதற்கு முன்பு பயன்படுத்தப்படும் போது ஒரு குறிப்பு பிழை ஏற்படுகிறது. இதைத் தடுக்க, எப்போதும் மாறிகள் என அறிவிக்கவும் let அல்லது const அவர்களை அழைக்கும் முன்.
"eth is not defined" பிழையை நான் எப்படி சரி செய்வது?
'eth' ஒரு சரமாக வழங்கப்படுவதை உறுதிசெய்யவும், வரையறுக்கப்படாத மாறி அல்ல. செயல்பாட்டை அழைக்கவும் gc('eth', 'usd').
ஸ்கிரிப்டில் fetch()ன் பங்கு என்ன?
தி fetch() செயல்பாடு ஒரு HTTP கோரிக்கையை API இறுதிப்புள்ளிக்கு அனுப்புகிறது. வெளிப்புறச் சேவையிலிருந்து தரவைத் தீர்க்கும் வாக்குறுதியை இது வழங்குகிறது.
API அழைப்பின் போது பிழைகளை எவ்வாறு கையாள்வது?
பிழைகளைக் கையாள, பயன்படுத்தவும் .catch() வாக்குறுதிக்குப் பிறகு அல்லது குறியீட்டை அ try...catch விதிவிலக்குகளைப் பிடிக்க தடை.
ஜாவாஸ்கிரிப்டில் லெட் மற்றும் வார் இடையே என்ன வித்தியாசம்?
let பிளாக்-ஸ்கோப் உள்ளது, அதாவது இது அருகிலுள்ள சுருள் அடைப்புக்குறிக்குள் மட்டுமே வாழ்கிறது, ஆனால் var செயல்பாடு-நோக்கம் கொண்டது மற்றும் சரியாகப் பயன்படுத்தப்படாவிட்டால் எதிர்பாராத நடத்தை ஏற்படலாம்.

ஜாவாஸ்கிரிப்ட் ஏபிஐ அழைப்புச் சிக்கல்களைச் சரிசெய்வதற்கான முக்கிய அம்சங்கள்

ஜாவாஸ்கிரிப்டில் உள்ள "குறிப்புப் பிழையை" சரிசெய்வது, பயன்படுத்துவதற்கு முன் மாறிகள் சரியாக வரையறுக்கப்பட்டிருப்பதை உறுதிப்படுத்துகிறது. 'eth' போன்ற அளவுருக்களை சரங்களாக வரையறுத்து, உடனடி சிக்கலை சரிசெய்ய உள்ளீடுகளை சரிபார்க்கவும்.

இந்த உத்தி, பயன்படுத்தி போதுமான பிழை கையாளுதல் இணைந்து பிடிக்க () மற்றும் உள்ளீடு சரிபார்ப்பு, வெளிப்புற API களைக் கையாள்வதற்கான மீள் குறியீட்டை ஏற்படுத்தலாம். இது மிகவும் திறமையான செயல்முறைகள் மற்றும் இயக்க நேர தவறுகளை குறைக்கும் போது சிறந்த பயனர் அனுபவத்தை உறுதி செய்கிறது.

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

ஜாவாஸ்கிரிப்ட் பற்றிய கூடுதல் தகவலுக்கு குறிப்புப் பிழை மற்றும் மாறி அறிவிப்புகள், Mozilla Developer Network (MDN) ஐப் பார்வையிடவும்: MDN - குறிப்புப் பிழை: வரையறுக்கப்படவில்லை .
சரியான பயன்பாடு பற்றி அறிய பெறு() JavaScript இல் API அழைப்புகளுக்கான செயல்பாடு, MDN இல் அதிகாரப்பூர்வ Fetch API ஆவணத்தைப் பார்க்கவும்: MDN - Fetch API .
பயன்படுத்துவதற்கான வழிகாட்டுதலுக்காக அச்சுகள் HTTP கோரிக்கைகளைக் கையாள Node.js இல் உள்ள நூலகம், Axios GitHub களஞ்சியத்தைப் பார்க்கவும்: ஆக்சியோஸ் - கிட்ஹப் .
எப்படி செயல்படுத்துவது என்று ஆராய வேண்டும் அலகு சோதனை Jest ஐப் பயன்படுத்தி JavaScript செயல்பாடுகளுக்கு, அதிகாரப்பூர்வ Jest ஆவணத்தைப் பார்க்கவும்: ஜெஸ்ட் - அதிகாரப்பூர்வ ஆவணம் .

ஜாவாஸ்கிரிப்ட் செயல்பாடு அழைப்பு தோல்வியை சரிசெய்தல்: வரையறுக்கப்படாத மாறிகள் காரணமாக குறிப்பு பிழை