JavaScript ਫੰਕਸ਼ਨ ਕਾਲ ਅਸਫਲਤਾ

Isanes Francois

ਸ਼ਨਿੱਚਰਵਾਰ, 5 ਅਕਤੂਬਰ 2024 2:25:45 ਪੂ.ਦੁ.

JavaScript ਰੈਫਰੈਂਸ ਐਰਰ ਅਤੇ ਇਸ ਦੇ ਫਿਕਸ ਨੂੰ ਸਮਝਣਾ

ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਏ ਹਵਾਲਾ ਗਲਤੀ ਤੰਗ ਕਰਨ ਵਾਲਾ ਹੋ ਸਕਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਇਹ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ। ਇੱਕ ਪ੍ਰਚਲਿਤ ਦ੍ਰਿਸ਼ ਇਹ ਹੈ ਕਿ ਵੇਰੀਏਬਲ ਵਰਤੋਂ ਤੋਂ ਪਹਿਲਾਂ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਨਤੀਜੇ ਵਜੋਂ ਅਜਿਹੀਆਂ ਗਲਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ।

ਸਮੱਸਿਆ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਨ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਹੈ ਜੋ ਇੱਕ ਬਾਹਰੀ API ਤੋਂ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਇਹ ਖਾਸ ਮੁੱਦਾ ਫੰਕਸ਼ਨ ਕਾਲ ਵਿੱਚ ਸਹੀ ਢੰਗ ਨਾਲ ਘੋਸ਼ਿਤ ਨਾ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਵੇਰੀਏਬਲਾਂ ਤੋਂ ਪੈਦਾ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਿਆ ਨਹੀਂ ਗਿਆ, ਤਾਂ ਇਹ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਤੋੜਨ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ।

ਭਾਵੇਂ ਤੁਸੀਂ JavaScript APIs ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ ਜਾਂ ਗਤੀਸ਼ੀਲ ਮੁੱਲਾਂ ਨਾਲ ਇੱਕ ਸਕ੍ਰਿਪਟ ਬਣਾ ਰਹੇ ਹੋ, ਉਹਨਾਂ ਨੂੰ ਪਾਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ। ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਤੁਸੀਂ "ਸੰਦਰਭ ਗਲਤੀ: ਵੇਰੀਏਬਲ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ" ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।

ਇਹ ਪੋਸਟ ਦੱਸੇਗੀ ਕਿ ਤੁਹਾਡੇ ਜਾਵਾਸਕ੍ਰਿਪਟ ਫੰਕਸ਼ਨ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ ਹਵਾਲਾ ਗਲਤੀ. ਅਸੀਂ ਭਵਿੱਖ ਦੇ ਲਾਗੂਕਰਨਾਂ ਵਿੱਚ ਇਸ ਮੁੱਦੇ ਤੋਂ ਬਚਣ ਲਈ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਅਤੇ ਪਾਸ ਕਰਨ ਦੇ ਤਰੀਕੇ ਬਾਰੇ ਵੀ ਦੱਸਾਂਗੇ।

ਹੁਕਮ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
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()	ਜੈਸਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਰੱਦ ਕਰਦਾ ਹੈ.toThrow() ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਢੰਗ ਹੈ ਕਿ ਵਾਅਦਾ ਇੱਕ ਗਲਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇਹ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਇੱਕ ਅਸਵੀਕਾਰ ਕੀਤੀ API ਕਾਲ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਜਾਅਲੀ ਨੈੱਟਵਰਕ ਮੁੱਦੇ।
document.body.innerHTML	DOM ਹੇਰਾਫੇਰੀ ਕਮਾਂਡ document.body.innerHTML ਪੰਨੇ 'ਤੇ ਸਰੀਰ ਦੇ ਤੱਤ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਸੋਧਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਿੱਚ, ਪ੍ਰਾਪਤ ਕੀਤੀ ਮੁਦਰਾ ਦਰ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਵੈਬਪੇਜ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦੀ ਹੈ।

JavaScript API ਕਾਲਾਂ ਵਿੱਚ ਹਵਾਲਾ ਗਲਤੀ ਨੂੰ ਹੱਲ ਕਰਨਾ

ਪੇਸ਼ ਕੀਤੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ, JavaScript ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਉਦੇਸ਼ ਇੱਕ API, ਖਾਸ ਤੌਰ 'ਤੇ BitPay ਸੇਵਾ ਤੋਂ ਐਕਸਚੇਂਜ ਦਰਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ। ਮੁੱਖ ਮੁੱਦਾ ਏ ਹਵਾਲਾ ਗਲਤੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪਰਿਭਾਸ਼ਿਤ ਵੇਰੀਏਬਲ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ gc() ਫੰਕਸ਼ਨ. ਇਸ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਨ ਲਈ, ਪਹਿਲਾ ਕਦਮ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਨੂੰ ਦਿੱਤੇ ਗਏ ਮਾਪਦੰਡ, ਜਿਵੇਂ ਕਿ 'eth' ਅਤੇ 'usd', ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਤਰ ਵਜੋਂ ਘੋਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਅਣ-ਪਰਿਭਾਸ਼ਿਤ ਵੇਰੀਏਬਲਾਂ ਨੂੰ JavaScript ਦੁਆਰਾ ਸੰਸਾਧਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਇਸਲਈ ਉਹਨਾਂ ਨੂੰ ਕੋਟਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਨਾਲ ਸਮੱਸਿਆ ਹੱਲ ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਬੇਨਤੀ ਨੂੰ ਸਹੀ URL ਨਿਰਮਾਣ ਨਾਲ ਅੱਗੇ ਵਧਣ ਦੀ ਇਜਾਜ਼ਤ ਮਿਲਦੀ ਹੈ।

ਫੈਚ API ਇਸ ਪਹੁੰਚ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸਾ ਹੈ, ਜਿਸ ਨਾਲ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇੱਕ ਬਾਹਰੀ ਸਰਵਰ ਤੋਂ ਅਸਿੰਕਰੋਨਸ ਤੌਰ 'ਤੇ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, get() ਦੋ ਪੈਰਾਮੀਟਰਾਂ (var1 ਅਤੇ var2) ਦੁਆਰਾ ਦਰਸਾਏ URL ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜਦਾ ਹੈ। URL ਢਾਂਚਾ ਨਾਜ਼ੁਕ ਹੈ, ਅਤੇ ਇਸਦੀ ਗਤੀਸ਼ੀਲ ਪੀੜ੍ਹੀ ਗਾਰੰਟੀ ਦਿੰਦੀ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਦੇ ਅਧਾਰ 'ਤੇ ਉਚਿਤ ਅੰਤ ਬਿੰਦੂ ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਬਾਅਦ, ਇਸ ਨੂੰ ਵਰਤ ਕੇ ਪਾਰਸ ਕੀਤਾ ਗਿਆ ਹੈ res.json() ਜਵਾਬ ਨੂੰ JSON ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣ ਲਈ। ਨਤੀਜੇ ਵਜੋਂ ਐਕਸਚੇਂਜ ਰੇਟ ਨੂੰ ਫਿਰ HTML ਬਾਡੀ ਵਿੱਚ DOM ਸੋਧ ਦੁਆਰਾ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਉਪਭੋਗਤਾ ਇੰਟਰਫੇਸ ਨੂੰ ਰੀਅਲ ਟਾਈਮ ਵਿੱਚ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ।

Node.js ਸੰਸਕਰਣ ਵਿੱਚ, ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ axios ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਬਜਾਏ, ਬੈਕਐਂਡ ਸੰਦਰਭਾਂ ਵਿੱਚ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਹੋਰ ਮਜ਼ਬੂਤ ਪੈਕੇਜ। Axios ਗਲਤੀ ਨੂੰ ਸੰਭਾਲਣ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਜਵਾਬ ਪਾਰਸਿੰਗ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸੁਚਾਰੂ ਬਣਾਉਂਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਐਕਸੀਓਸ API ਅੰਤਮ ਬਿੰਦੂ ਨੂੰ ਇੱਕ GET ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਡੇਟਾ ਇਕੱਠਾ ਕਰਦਾ ਹੈ, ਅਤੇ ਕੰਸੋਲ ਵਿੱਚ ਐਕਸਚੇਂਜ ਦਰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਕ੍ਰਿਪਟ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ ਕਿ API ਕਾਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਫੰਕਸ਼ਨ ਵਿੱਚ ਦੋਵੇਂ ਪੈਰਾਮੀਟਰ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ, ਗਲਤੀ ਦੇ ਇੱਕ ਹੋਰ ਸੰਭਾਵੀ ਸਰੋਤ ਨੂੰ ਹਟਾਉਂਦੇ ਹੋਏ।

ਇਹਨਾਂ ਕਾਰਜਸ਼ੀਲਤਾਵਾਂ ਦੀ ਸਥਿਰਤਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ, ਯੂਨਿਟ ਟੈਸਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਿਖੇ ਗਏ ਸਨ ਮਜ਼ਾਕ ਫਰੇਮਵਰਕ ਇਹ ਟੈਸਟ ਸਫਲ ਅਤੇ ਅਸਫਲ API ਕਾਲਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ ਐਕਸੀਓਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਧੋਖਾ ਦਿੰਦੇ ਹਨ। ਇਹ ਸਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਸਾਰੇ ਸੰਭਾਵੀ ਦ੍ਰਿਸ਼ਾਂ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਜਦੋਂ API ਇੱਕ ਵੈਧ ਦਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜਾਂ ਜਦੋਂ ਕੋਈ ਗਲਤੀ ਹੁੰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਨੈੱਟਵਰਕ ਆਊਟੇਜ। ਇਹਨਾਂ ਟੈਸਟਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਕੇ, ਅਸੀਂ ਕੋਡ ਨੂੰ ਪ੍ਰੋਡਕਸ਼ਨ ਵਾਤਾਵਰਨ ਵਿੱਚ ਭਰੋਸੇ ਨਾਲ ਜਾਰੀ ਕਰ ਸਕਦੇ ਹਾਂ, ਇਹ ਜਾਣਦੇ ਹੋਏ ਕਿ ਇਹ ਉਮੀਦ ਅਨੁਸਾਰ ਪ੍ਰਦਰਸ਼ਨ ਕਰੇਗਾ। ਦੋਵੇਂ ਫਰੰਟ-ਐਂਡ ਅਤੇ ਬੈਕ-ਐਂਡ ਹੱਲਾਂ ਦੀ ਵਰਤੋਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਸਮੱਸਿਆ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਹੱਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਗਲਤੀ ਲਚਕੀਲੇਪਣ ਦੋਵਾਂ ਨੂੰ ਵਧਾਉਣ 'ਤੇ ਜ਼ੋਰ ਦਿੱਤਾ ਗਿਆ ਹੈ।

ਰੈਫਰੈਂਸ ਐਰਰ ਨੂੰ ਹੱਲ ਕਰਨਾ: ਵੇਰੀਏਬਲ JavaScript API ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹਨ

ਇਹ ਪਹੁੰਚ ਇੱਕ ਬੁਨਿਆਦੀ ਫਰੰਟਐਂਡ JavaScript ਵਿਧੀ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦੀ ਹੈ ਜੋ ਇੱਕ ਬਾਹਰੀ ਸੇਵਾ ਤੋਂ ਦਰਾਂ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਫੈਚ 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 ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਵੇਰੀਏਬਲ ਅਤੇ ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਨੂੰ ਸੰਭਾਲਣਾ

ਇਹ ਬੈਕਐਂਡ ਤਕਨੀਕ ਏਪੀਆਈ ਬੇਨਤੀ ਲਈ 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');

ਜੈਸਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ JavaScript ਵਿੱਚ getRates ਫੰਕਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰਨ ਵਾਲੀ ਯੂਨਿਟ

ਇਹ ਟੈਸਟ ਸਕ੍ਰਿਪਟ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਜੈਸਟ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਸਫਲ API ਬੇਨਤੀਆਂ ਅਤੇ ਗਲਤੀ ਸਥਿਤੀਆਂ ਸਮੇਤ ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਦ੍ਰਿਸ਼ਾਂ ਨੂੰ ਸੰਭਾਲ ਸਕਦਾ ਹੈ।

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 ਕਾਲਾਂ ਵਿੱਚ ਵੇਰੀਏਬਲ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ

ਸਹੀ ਵੇਰੀਏਬਲ ਸਕੋਪ ਅਤੇ ਸ਼ੁਰੂਆਤ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹਨ ਹਵਾਲਾ ਗਲਤੀ JavaScript ਵਿੱਚ, ਖਾਸ ਤੌਰ 'ਤੇ API ਕਾਲਾਂ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ। JavaScript ਵਿੱਚ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਅਤੇ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ, ਵਰਤੋਂ ਚਲੋ ਜਾਂ const. ਵਰਤੋਂ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਅਸਫਲਤਾ, ਜਾਂ ਉਹਨਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਦਾਇਰੇ ਤੋਂ ਬਾਹਰ ਬੁਲਾਉਣ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਅਕਸਰ "ਰੈਫਰੈਂਸ ਐਰਰ: ਵੇਰੀਏਬਲ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ" ਵਰਗੀਆਂ ਗਲਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। API ਸਵਾਲਾਂ ਨੂੰ ਬਣਾਉਣ ਵੇਲੇ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ ਕਿ ਆਰਗੂਮੈਂਟਸ ਸਹੀ ਢੰਗ ਨਾਲ ਭਰੀਆਂ ਗਈਆਂ ਹਨ।

ਬਾਹਰੀ APIs ਨਾਲ ਇੰਟਰਫੇਸ ਕਰਨ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਵੇਲੇ, ਤੁਹਾਨੂੰ ਕਾਰਵਾਈਆਂ ਦੀ ਅਸਿੰਕ੍ਰੋਨਸ ਪ੍ਰਕਿਰਤੀ ਨੂੰ ਵੀ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ। ਜਦੋਂ ਕਿ fetch API ਵਾਅਦਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਸਿੰਕਰੋਨਸ ਗਤੀਵਿਧੀਆਂ ਨੂੰ ਹੈਂਡਲ ਕਰਦਾ ਹੈ, ਇਸਦੇ ਨਾਲ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਨੂੰ ਜੋੜਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕੋਸ਼ਿਸ਼ ਕਰੋ...ਫੜੋ ਬਲਾਕ ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ .catch() ਸੰਭਾਵਿਤ ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਹਾਸਲ ਕਰਨ ਦੇ ਵਾਅਦੇ ਤੋਂ ਬਾਅਦ ਫੰਕਸ਼ਨ. ਇਹ ਪੂਰੀ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਰੁਕਾਵਟ ਪਾਉਣ ਤੋਂ ਅਚਾਨਕ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਰੋਕਦਾ ਹੈ। ਵਧੀਆ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਸ਼ਾਨਦਾਰ ਅਸਫਲਤਾ ਅਤੇ ਸੰਬੰਧਿਤ ਗਲਤੀ ਸੁਨੇਹਿਆਂ ਲਈ ਪ੍ਰਦਾਨ ਕਰਕੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦਾ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਬਾਹਰੀ API ਸਵਾਲਾਂ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਸੁਰੱਖਿਆ ਨੂੰ ਸੰਬੋਧਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਸਾਰੇ ਆਉਣ ਵਾਲੇ ਡੇਟਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਸਾਡੀ ਸਥਿਤੀ ਵਿੱਚ ਮੁਦਰਾਵਾਂ ਜਿਵੇਂ ਕਿ ਬਦਲਣਯੋਗ ਮਾਪਦੰਡਾਂ ਨਾਲ ਨਜਿੱਠਣਾ ਹੋਵੇ। API ਬੇਨਤੀ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਨਪੁਟਸ ਨੂੰ ਸੈਨੀਟਾਈਜ਼ ਕਰਨਾ API ਦੀ ਦੁਰਵਰਤੋਂ ਜਾਂ ਇੰਜੈਕਸ਼ਨ ਹਮਲਿਆਂ ਵਰਗੀਆਂ ਸੰਭਾਵੀ ਸੁਰੱਖਿਆ ਕਮਜ਼ੋਰੀਆਂ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਇਨਪੁਟ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸਾਂ ਦਾ ਪਾਲਣ ਕਰਨਾ ਅਤੇ URL ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਡੇਟਾ ਦੀ ਸਿੱਧੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣਾ ਆਧੁਨਿਕ ਵੈੱਬ ਵਿਕਾਸ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਚਾਲ ਹੈ।

JavaScript API ਕਾਲ ਗਲਤੀਆਂ 'ਤੇ ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ

JavaScript ਵਿੱਚ ਰੈਫਰੈਂਸ ਐਰਰ ਦਾ ਕੀ ਕਾਰਨ ਹੈ?
ਇੱਕ ਹਵਾਲਾ ਗਲਤੀ ਉਦੋਂ ਵਾਪਰਦੀ ਹੈ ਜਦੋਂ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਨੂੰ ਰੋਕਣ ਲਈ, ਹਮੇਸ਼ਾ ਵੇਰੀਏਬਲ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਘੋਸ਼ਿਤ ਕਰੋ let ਜਾਂ const ਉਹਨਾਂ ਨੂੰ ਬੁਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ.
ਮੈਂ "ਈਥ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ" ਗਲਤੀ ਨੂੰ ਕਿਵੇਂ ਠੀਕ ਕਰ ਸਕਦਾ ਹਾਂ?
ਯਕੀਨੀ ਬਣਾਓ ਕਿ 'eth' ਨੂੰ ਇੱਕ ਸਤਰ ਵਜੋਂ ਸਪਲਾਈ ਕੀਤਾ ਗਿਆ ਹੈ, ਨਾ ਕਿ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ ਵੇਰੀਏਬਲ। ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ gc('eth', 'usd').
ਸਕ੍ਰਿਪਟ ਵਿੱਚ fetch() ਦੀ ਕੀ ਭੂਮਿਕਾ ਹੈ?
ਦ fetch() ਫੰਕਸ਼ਨ API ਐਂਡਪੁਆਇੰਟ ਨੂੰ HTTP ਬੇਨਤੀ ਭੇਜਦਾ ਹੈ। ਇਹ ਇੱਕ ਵਾਅਦਾ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਬਾਹਰੀ ਸੇਵਾ ਤੋਂ ਡੇਟਾ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ।
ਮੈਂ ਇੱਕ API ਕਾਲ ਦੌਰਾਨ ਗਲਤੀਆਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲ ਸਕਦਾ/ਸਕਦੀ ਹਾਂ?
ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ, ਵਰਤੋ .catch() ਵਾਅਦੇ ਤੋਂ ਬਾਅਦ ਜਾਂ ਕੋਡ ਨੂੰ ਏ ਵਿੱਚ ਲਪੇਟੋ try...catch ਅਪਵਾਦਾਂ ਨੂੰ ਫੜਨ ਲਈ ਬਲਾਕ ਕਰੋ।
JavaScript ਵਿੱਚ let ਅਤੇ var ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ?
let ਬਲਾਕ-ਸਕੋਪਡ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਸਿਰਫ ਕਰਲੀ ਬਰੈਕਟਾਂ ਦੇ ਨਜ਼ਦੀਕੀ ਸਮੂਹ ਦੇ ਅੰਦਰ ਰਹਿੰਦਾ ਹੈ, ਪਰ var ਫੰਕਸ਼ਨ-ਸਕੋਪਡ ਹੈ ਅਤੇ ਜੇਕਰ ਸਹੀ ਢੰਗ ਨਾਲ ਨਹੀਂ ਵਰਤਿਆ ਗਿਆ ਤਾਂ ਇਹ ਅਚਾਨਕ ਵਿਵਹਾਰ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ।

JavaScript API ਕਾਲ ਮੁੱਦਿਆਂ ਨੂੰ ਫਿਕਸ ਕਰਨ ਲਈ ਮੁੱਖ ਉਪਾਅ

JavaScript ਵਿੱਚ "ਰੈਫਰੈਂਸ ਐਰਰ" ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਵੇਰੀਏਬਲ ਵਰਤਣ ਤੋਂ ਪਹਿਲਾਂ ਸਹੀ ਢੰਗ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ। 'eth' ਵਰਗੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਸਤਰ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਅਤੇ ਤਤਕਾਲ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਇਨਪੁਟਸ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰੋ।

ਇਹ ਰਣਨੀਤੀ, ਦੀ ਵਰਤੋਂ ਨਾਲ ਢੁਕਵੀਂ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਦੇ ਨਾਲ ਜੋੜੀ ਗਈ ਹੈ ਫੜੋ() ਅਤੇ ਇਨਪੁਟ ਪ੍ਰਮਾਣਿਕਤਾ, ਬਾਹਰੀ APIs ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਲਚਕੀਲੇ ਕੋਡ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਹੋ ਸਕਦਾ ਹੈ। ਇਹ ਰਨਟਾਈਮ ਗਲਤੀਆਂ ਨੂੰ ਘਟਾਉਂਦੇ ਹੋਏ ਵਧੇਰੇ ਕੁਸ਼ਲ ਪ੍ਰਕਿਰਿਆਵਾਂ ਅਤੇ ਇੱਕ ਬਿਹਤਰ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।

JavaScript ਫੰਕਸ਼ਨ ਗਲਤੀਆਂ ਅਤੇ API ਹੈਂਡਲਿੰਗ ਲਈ ਹਵਾਲੇ

JavaScript ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ ਹਵਾਲਾ ਗਲਤੀ ਅਤੇ ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾਵਾਂ, ਮੋਜ਼ੀਲਾ ਡਿਵੈਲਪਰ ਨੈੱਟਵਰਕ (MDN) 'ਤੇ ਜਾਓ: MDN - ਹਵਾਲਾ ਗਲਤੀ: ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ .
ਦੀ ਸਹੀ ਵਰਤੋਂ ਬਾਰੇ ਜਾਣਨ ਲਈ ਪ੍ਰਾਪਤ ਕਰੋ() JavaScript ਵਿੱਚ API ਕਾਲਾਂ ਲਈ ਫੰਕਸ਼ਨ, MDN 'ਤੇ ਅਧਿਕਾਰਤ Fetch API ਦਸਤਾਵੇਜ਼ ਵੇਖੋ: MDN - API ਪ੍ਰਾਪਤ ਕਰੋ .
ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਮਾਰਗਦਰਸ਼ਨ ਲਈ axios HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ Node.js ਵਿੱਚ ਲਾਇਬ੍ਰੇਰੀ, Axios GitHub ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਸਲਾਹ ਲਓ: Axios - GitHub .
ਲਾਗੂ ਕਰਨ ਦੇ ਤਰੀਕੇ ਦੀ ਪੜਚੋਲ ਕਰਨ ਲਈ ਯੂਨਿਟ ਟੈਸਟਿੰਗ ਜੈਸਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ JavaScript ਫੰਕਸ਼ਨਾਂ ਲਈ, ਅਧਿਕਾਰਤ ਜੇਸਟ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਜਾਂਚ ਕਰੋ: ਜੈਸਟ - ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ .

JavaScript ਫੰਕਸ਼ਨ ਕਾਲ ਅਸਫਲਤਾ ਨੂੰ ਠੀਕ ਕਰਨਾ: ਪਰਿਭਾਸ਼ਿਤ ਵੇਰੀਏਬਲ ਦੇ ਕਾਰਨ ਹਵਾਲਾ ਗਲਤੀ