జావాస్క్రిప్ట్

Isanes Francois

5, అక్టోబర్ 2024, శనివారం 2:51:01 AMకి

జావాస్క్రిప్ట్ రిఫరెన్స్ ఎర్రర్ మరియు దాని పరిష్కారాలను అర్థం చేసుకోవడం

జావాస్క్రిప్ట్‌లో, a సూచన లోపం చికాకు కలిగించవచ్చు, ప్రత్యేకించి మీ కోడ్ అమలును ఆపివేసినప్పుడు. ఒక ప్రబలమైన దృష్టాంతం ఏమిటంటే, వేరియబుల్స్ వినియోగానికి ముందు పేర్కొనబడలేదు, ఫలితంగా ఇటువంటి లోపాలు ఏర్పడతాయి.

బాహ్య API నుండి డేటాను తిరిగి పొందే ఫంక్షన్‌కి కాల్ చేయడంలో సమస్య ఉంది. ఫంక్షన్ కాల్‌లో వేరియబుల్స్ సరిగ్గా ప్రకటించబడకపోవడం వల్ల ఈ ప్రత్యేక సమస్య ఏర్పడింది. సరిగ్గా హ్యాండిల్ చేయకపోతే, ఇది మీ కోడ్ విచ్ఛిన్నం కావడానికి కారణం కావచ్చు.

మీరు JavaScript 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()	జెస్ట్ ఉపయోగిస్తుంది తిరస్కరిస్తుంది.టు త్రో() వాగ్దానం లోపాన్ని తిరిగి పొందేలా చూసే పద్ధతి. నకిలీ నెట్‌వర్క్ సమస్యలు వంటి తిరస్కరించబడిన API కాల్‌ని ఫంక్షన్ ఎలా నిర్వహిస్తుందో మూల్యాంకనం చేసేటప్పుడు ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది.
document.body.innerHTML	DOM మానిప్యులేషన్ కమాండ్ document.body.innerHTML పేజీలోని శరీర మూలకం యొక్క కంటెంట్‌ను సవరిస్తుంది. ఉదాహరణలో, పొందిన కరెన్సీ రేటు వెబ్‌పేజీలో డైనమిక్‌గా ప్రదర్శించబడుతుంది.

JavaScript API కాల్‌లలో రిఫరెన్స్ లోపాన్ని పరిష్కరిస్తోంది

అందించబడిన ఉదాహరణలలో, జావాస్క్రిప్ట్ స్క్రిప్ట్‌లు API నుండి ప్రత్యేకంగా BitPay సేవ నుండి మార్పిడి రేట్లను తిరిగి పొందేందుకు ఉద్దేశించబడ్డాయి. ప్రధాన సమస్య ఎ సూచన లోపం ఉపయోగిస్తున్నప్పుడు నిర్వచించబడని వేరియబుల్స్ ద్వారా రూపొందించబడింది gc() ఫంక్షన్. దీనిని పరిష్కరించడానికి, ఫంక్షన్‌కు అందించబడిన 'eth' మరియు 'usd' వంటి పారామీటర్‌లు స్ట్రింగ్‌లుగా సరిగ్గా ప్రకటించబడ్డాయని నిర్ధారించుకోవడం మొదటి దశ. నిర్వచించబడని వేరియబుల్స్ JavaScript ద్వారా ప్రాసెస్ చేయబడవు, కాబట్టి వాటిని కోట్‌లలో చేర్చడం సమస్యను పరిష్కరిస్తుంది మరియు సరైన URL నిర్మాణంతో కొనసాగడానికి పొందే అభ్యర్థనను అనుమతిస్తుంది.

ఫెచ్ API అనేది ఈ విధానంలో కీలకమైన భాగం, ఇది బాహ్య సర్వర్ నుండి డేటాను అసమకాలికంగా పొందేందుకు స్క్రిప్ట్‌ను అనుమతిస్తుంది. ఈ ఉదాహరణలో, get() రెండు పారామితులు (var1 మరియు var2) ద్వారా పేర్కొన్న URLకి HTTP అభ్యర్థనను పంపుతుంది. URL నిర్మాణం కీలకమైనది మరియు దాని డైనమిక్ జనరేషన్ వినియోగదారు ఇన్‌పుట్ ఆధారంగా తగిన ముగింపు బిందువుగా పిలువబడుతుందని హామీ ఇస్తుంది. డేటాను తిరిగి పొందిన తర్వాత, అది ఉపయోగించి అన్వయించబడుతుంది res.json() ప్రతిస్పందనను JSON ఆకృతిలోకి మార్చడానికి. ఫలితంగా మారకం రేటు DOM సవరణ ద్వారా HTML బాడీలో చూపబడుతుంది, ఇది వినియోగదారు ఇంటర్‌ఫేస్‌ను నిజ సమయంలో అప్‌డేట్ చేస్తుంది.

Node.js సంస్కరణలో, మేము ఉపయోగిస్తాము అక్షాంశాలు పొందుటకు బదులుగా, బ్యాకెండ్ సందర్భాలలో HTTP అభ్యర్థనలను నిర్వహించడానికి మరింత బలమైన ప్యాకేజీ. Axios ఎర్రర్ హ్యాండ్లింగ్‌ను మెరుగుపరుస్తుంది మరియు ప్రతిస్పందన పార్సింగ్ ప్రక్రియను క్రమబద్ధీకరిస్తుంది. స్క్రిప్ట్‌లో, axios API ఎండ్‌పాయింట్‌కి GET అభ్యర్థనను చేస్తుంది, డేటాను సేకరిస్తుంది మరియు కన్సోల్‌లో మార్పిడి రేటును ప్రదర్శిస్తుంది. ఇంకా, స్క్రిప్ట్ API కాల్ చేయడానికి ముందు ఫంక్షన్‌లో రెండు పారామితులు అందించబడిందని నిర్ధారిస్తుంది, ఇది మరొక సంభావ్య లోపం మూలాన్ని తొలగిస్తుంది.

ఈ ఫంక్షనాలిటీల స్థిరత్వాన్ని ధృవీకరించడానికి, యూనిట్ పరీక్షలను ఉపయోగించి వ్రాయబడింది జస్ట్ ఫ్రేమ్వర్క్. ఈ పరీక్షలు విజయవంతమైన మరియు విఫలమైన API కాల్‌లను పునరావృతం చేయడానికి axios లైబ్రరీని మోసగిస్తాయి. API చెల్లుబాటు అయ్యే రేట్‌ను అందించినప్పుడు లేదా నెట్‌వర్క్ అంతరాయం వంటి లోపం సంభవించినప్పుడు వంటి సాధ్యమయ్యే అన్ని దృశ్యాలను ఫంక్షన్ కవర్ చేస్తుందని నిర్ధారించుకోవడానికి ఇది మాకు సహాయపడుతుంది. ఈ పరీక్షలను చేర్చడం ద్వారా, అది ఊహించిన విధంగా పని చేస్తుందని తెలుసుకుని, ఉత్పత్తి పరిసరాలలో మేము నమ్మకంగా కోడ్‌ని విడుదల చేయవచ్చు. ఫ్రంట్-ఎండ్ మరియు బ్యాక్-ఎండ్ సొల్యూషన్స్ రెండింటినీ ఉపయోగించడం వల్ల సమస్య పూర్తిగా పరిష్కరించబడిందని నిర్ధారిస్తుంది, పనితీరు మరియు లోపం స్థితిస్థాపకత రెండింటినీ పెంచడం.

రిఫరెన్స్ లోపాన్ని పరిష్కరిస్తోంది: జావాస్క్రిప్ట్ API పొందడంలో వేరియబుల్స్ నిర్వచించబడలేదు

ఈ విధానం ప్రాథమిక ఫ్రంటెండ్ జావాస్క్రిప్ట్ పద్ధతిపై దృష్టి పెడుతుంది, ఇది బాహ్య సేవ నుండి రేట్‌లను తిరిగి పొందేందుకు 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 మరియు యాక్సియోలను ఉపయోగించుకుంటుంది.

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ని ఉపయోగించి జావాస్క్రిప్ట్‌లో 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');
});

JavaScript API కాల్స్‌లో వేరియబుల్ డెఫినిషన్‌లను నిర్వహించడం

సరైన వేరియబుల్ స్కోప్ మరియు ప్రారంభించడం వ్యవహరించడానికి కీలకం సూచన లోపం జావాస్క్రిప్ట్‌లో, ముఖ్యంగా API కాల్‌లతో వ్యవహరించేటప్పుడు. జావాస్క్రిప్ట్‌లో వేరియబుల్‌లను సరిగ్గా నిర్వచించడానికి మరియు డిక్లేర్ చేయడానికి, ఉపయోగించండి వీలు లేదా స్థిరంగా. వినియోగానికి ముందు వేరియబుల్స్ డిక్లేర్ చేయడంలో వైఫల్యం లేదా వాటి పరిధికి వెలుపల వాటిని కాల్ చేయడం, తరచుగా "రిఫరెన్స్ ఎర్రర్: వేరియబుల్ నిర్వచించబడలేదు" వంటి ఎర్రర్‌లకు దారి తీస్తుంది. API ప్రశ్నలను చేస్తున్నప్పుడు, ఆర్గ్యుమెంట్‌లు సరిగ్గా ఉండేలా చూసుకోవడం చాలా కీలకం.

బాహ్య APIలతో ఇంటర్‌ఫేస్ చేసే అప్లికేషన్‌లను అభివృద్ధి చేస్తున్నప్పుడు, మీరు చర్యల యొక్క అసమకాలిక స్వభావాన్ని అదనంగా పరిగణించాలి. ఫెచ్ API వాగ్దానాలను ఉపయోగించి అసమకాలిక కార్యకలాపాలను నిర్వహిస్తుండగా, దోష నిర్వహణను జోడించడం చాలా ముఖ్యం ప్రయత్నించండి...పట్టుకోండి బ్లాక్స్ లేదా ఉపయోగించండి .catch() సంభావ్య వైఫల్యాలను సంగ్రహించే వాగ్దానం తర్వాత పని చేస్తుంది. ఇది మొత్తం అప్లికేషన్‌కు అంతరాయం కలిగించకుండా ఊహించని సమస్యలను నివారిస్తుంది. మంచి ఎర్రర్ హ్యాండ్లింగ్ ఆకర్షణీయమైన వైఫల్యం మరియు సంబంధిత ఎర్రర్ మెసేజ్‌లను అందించడం ద్వారా వినియోగదారు అనుభవాన్ని మెరుగుపరుస్తుంది.

ఇంకా, బాహ్య API ప్రశ్నలతో వ్యవహరించేటప్పుడు భద్రతను పరిష్కరించాలి. మీరు తప్పనిసరిగా అన్ని ఇన్‌కమింగ్ డేటాను ధృవీకరించాలి, ప్రత్యేకించి మా పరిస్థితిలో కరెన్సీల వంటి మార్చగల పారామితులతో వ్యవహరించేటప్పుడు. API అభ్యర్థన చేయడానికి ముందు ఇన్‌పుట్‌లను శుభ్రపరచడం API దుర్వినియోగం లేదా ఇంజెక్షన్ దాడుల వంటి సంభావ్య భద్రతా దుర్బలత్వాలను నిరోధించడంలో సహాయపడుతుంది. ఇన్‌పుట్ ధ్రువీకరణ కోసం ఉత్తమ పద్ధతులను అనుసరించడం మరియు URLలలో వినియోగదారు రూపొందించిన డేటా యొక్క ప్రత్యక్ష వినియోగాన్ని నివారించడం ఆధునిక వెబ్ అభివృద్ధిలో ఒక ముఖ్యమైన వ్యూహం.

JavaScript API కాల్ ఎర్రర్‌లపై తరచుగా అడిగే ప్రశ్నలు

జావాస్క్రిప్ట్‌లో రిఫరెన్స్ ఎర్రర్‌కు కారణమేమిటి?
వేరియబుల్ నిర్వచించబడక ముందే ఉపయోగించినప్పుడు సూచన లోపం సంభవిస్తుంది. దీన్ని నివారించడానికి, ఎల్లప్పుడూ వేరియబుల్స్‌ను ఇలా ప్రకటించండి let లేదా const వాటిని పిలవడానికి ముందు.
"eth is not defined" లోపాన్ని నేను ఎలా పరిష్కరించగలను?
'eth' అనేది స్ట్రింగ్‌గా సరఫరా చేయబడిందని నిర్ధారించుకోండి, నిర్వచించబడని వేరియబుల్ కాదు. ఫంక్షన్‌కి కాల్ చేయండి gc('eth', 'usd').
స్క్రిప్ట్‌లో ఫెచ్() పాత్ర ఏమిటి?
ది fetch() ఫంక్షన్ API ముగింపు పాయింట్‌కి HTTP అభ్యర్థనను పంపుతుంది. ఇది బాహ్య సేవ నుండి డేటాకు పరిష్కరించే వాగ్దానాన్ని అందిస్తుంది.
API కాల్ సమయంలో నేను లోపాలను ఎలా నిర్వహించగలను?
లోపాలను నిర్వహించడానికి, ఉపయోగించండి .catch() వాగ్దానం చేసిన తర్వాత లేదా కోడ్‌ను a లో చుట్టండి try...catch మినహాయింపులను పట్టుకోవడానికి బ్లాక్ చేయండి.
జావాస్క్రిప్ట్‌లో లెట్ మరియు వర్ మధ్య తేడా ఏమిటి?
let బ్లాక్-స్కోప్ చేయబడింది, అంటే ఇది సమీప వంకర బ్రాకెట్‌ల సెట్‌లో మాత్రమే నివసిస్తుంది, కానీ var ఫంక్షన్-స్కోప్డ్ మరియు సరిగ్గా ఉపయోగించకపోతే ఊహించని ప్రవర్తనకు కారణం కావచ్చు.

జావాస్క్రిప్ట్ API కాల్ సమస్యలను పరిష్కరించడంలో కీలకమైన అంశాలు

జావాస్క్రిప్ట్‌లో "రిఫరెన్స్ ఎర్రర్"ని సరిదిద్దడం అనేది వాడకానికి ముందు వేరియబుల్స్ సరిగ్గా నిర్వచించబడిందని నిర్ధారిస్తుంది. 'eth' వంటి పారామితులను స్ట్రింగ్‌లుగా నిర్వచించండి మరియు తక్షణ సమస్యను పరిష్కరించడానికి ఇన్‌పుట్‌లను ధృవీకరించండి.

ఈ వ్యూహం, ఉపయోగించి తగిన దోష నిర్వహణతో కలిపి క్యాచ్ () మరియు ఇన్‌పుట్ ధ్రువీకరణ, బాహ్య APIలతో వ్యవహరించడానికి స్థితిస్థాపకమైన కోడ్‌కు దారి తీస్తుంది. ఇది రన్‌టైమ్ తప్పులను తగ్గించేటప్పుడు మరింత సమర్థవంతమైన ప్రక్రియలను మరియు మెరుగైన వినియోగదారు అనుభవాన్ని నిర్ధారిస్తుంది.

జావాస్క్రిప్ట్ ఫంక్షన్ లోపాలు మరియు API హ్యాండ్లింగ్ కోసం సూచనలు

జావాస్క్రిప్ట్ గురించి మరింత సమాచారం కోసం సూచన లోపం మరియు వేరియబుల్ డిక్లరేషన్‌లు, మొజిల్లా డెవలపర్ నెట్‌వర్క్ (MDN)ని సందర్శించండి: MDN - ReferenceError: నిర్వచించబడలేదు .
యొక్క సరైన ఉపయోగం గురించి తెలుసుకోవడానికి పొందు() జావాస్క్రిప్ట్‌లో API కాల్‌ల ఫంక్షన్, MDNలో అధికారిక పొందు API డాక్యుమెంటేషన్‌ను చూడండి: MDN - పొందండి API .
ఉపయోగించడంపై మార్గదర్శకత్వం కోసం అక్షాంశాలు HTTP అభ్యర్థనలను నిర్వహించడానికి Node.jsలోని లైబ్రరీ, Axios GitHub రిపోజిటరీని సంప్రదించండి: యాక్సియోస్ - GitHub .
ఎలా అమలు చేయాలో అన్వేషించడానికి యూనిట్ పరీక్ష Jestని ఉపయోగించి JavaScript ఫంక్షన్ల కోసం, అధికారిక Jest డాక్యుమెంటేషన్‌ను తనిఖీ చేయండి: జెస్ట్ - అధికారిక డాక్యుమెంటేషన్ .

జావాస్క్రిప్ట్ ఫంక్షన్ కాల్ వైఫల్యాన్ని పరిష్కరించడం: నిర్వచించని వేరియబుల్స్ కారణంగా సూచన లోపం