ਵਿਸ਼ਾ - ਸੂਚੀ[ਛੁਪਾਓ][ਦਿਖਾਓ]
- 1. ਆਪਣੇ ਬੁਨਿਆਦੀ ਗਿਆਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰੋ
- 2. ਇੱਕ ਵਸਤੂ-ਅਧਾਰਿਤ ਰਣਨੀਤੀ ਦੀ ਵਰਤੋਂ ਕਰੋ
- 3. ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਭਾਵੇਂ ਉਹ ਛੋਟੇ ਹੋਣ
- 4. == ਦੀ ਬਜਾਏ, === ਦੀ ਵਰਤੋਂ ਕਰੋ
- 5. JSLint ਦੀ ਵਰਤੋਂ ਕਰੋ
- 6. ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਤੁਹਾਡੇ ਪੰਨੇ ਦੇ ਹੇਠਾਂ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ
- 7. ਸਤਰ ਬਣਾਉਣ ਦਾ ਸਭ ਤੋਂ ਤੇਜ਼ ਤਰੀਕਾ
- 8. ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਇੱਕ ਟਿੱਪਣੀ ਸ਼ਾਮਲ ਕਰੋ
- 9. ਟੈਂਪਲੇਟ ਲਿਟਰਲ ਦੀ ਵਰਤੋਂ ਕਰੋ
- 10. ਦੁਹਰਾਓ ਅਤੇ ਲੂਪਸ ਦੇ … ਲਈ
- 11. ਨਵੀਂ ਵਸਤੂ() ਦੀ ਬਜਾਏ {} ਦੀ ਵਰਤੋਂ ਕਰੋ
- 12. ਆਪਣੇ ਕੋਡ ਵਿੱਚ let ਅਤੇ const ਪਾਉਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ
- 13. eval() ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਨਹੀਂ ਹੈ
- 14. ਸਪ੍ਰੈਡ ਆਪਰੇਟਰ ਕੰਮ ਆਉਂਦਾ ਹੈ
- 15. ਉਡੀਕ ਕਰੋ ਅਤੇ ਅਸਿੰਕ ਕਰੋ
- 16. Javascript ਵਿੱਚ includes() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ
- 17. Splice ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਐਰੇ ਤੋਂ ਆਈਟਮਾਂ ਨੂੰ ਹਟਾਓ
- 18. ਐਰੋ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ
- 19. ਡਿਸਟ੍ਰਕਚਰਿੰਗ ਨਾਲ, ਤੁਸੀਂ ਤੇਜ਼ੀ ਨਾਲ ਵੇਰੀਏਬਲ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ
- 20. ਕਈ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ
- ਸਿੱਟਾ
ਜੇਕਰ ਤੁਸੀਂ ਕਦੇ ਵੀ ਵੈੱਬ ਵਿਕਾਸ ਵਿੱਚ ਦਿਲਚਸਪੀ ਲਈ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਸ਼ਾਇਦ JavaScript ਵਿੱਚ ਆਏ ਹੋ। ਇੱਕ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਹੈ। ਡਿਵੈਲਪਰ ਵੈੱਬ ਪੇਜਾਂ ਦੇ ਕਲਾਇੰਟ-ਸਾਈਡ (ਫਰੰਟ ਐਂਡ) ਨੂੰ ਗਤੀਸ਼ੀਲ ਅਤੇ ਇੰਟਰਐਕਟਿਵ ਬਣਾਉਣ ਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।
ਇਸਦੀ ਵਰਤੋਂ HTML ਅਤੇ CSS ਦੇ ਨਾਲ ਵੈੱਬ ਪੰਨਿਆਂ ਅਤੇ ਵੈਬ ਐਪਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਵੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅੱਜਕੱਲ੍ਹ ਇੰਟਰਨੈੱਟ 'ਤੇ ਕੋਈ ਅਜਿਹਾ ਵੈੱਬ ਪੰਨਾ ਨਹੀਂ ਹੈ ਜਿਸ ਵਿੱਚ JavaScript ਕੋਡ ਨਾ ਹੋਵੇ। ਇਹ ਇੱਕ ਡਿਵੈਲਪਰ ਦੀ ਨੌਕਰੀ ਦਾ ਇੱਕ ਅਟੁੱਟ ਪਹਿਲੂ ਬਣ ਗਿਆ ਹੈ।
ਦਰਅਸਲ, ਇਹ ਲਗਾਤਾਰ ਵਧ ਰਿਹਾ ਹੈ। ਹਾਲਾਂਕਿ JavaScript ਵੈਬ ਪੇਜਾਂ ਨੂੰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਮਾਨਤਾ ਪ੍ਰਾਪਤ ਹੈ, ਇਹ ਗੈਰ-ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਾਤਾਵਰਣ ਵਿੱਚ ਵੀ ਕੰਮ ਕਰਦੀ ਹੈ। Node.js, Apache Couch-DB, ਅਤੇ Adobe Acrobat ਇਹਨਾਂ ਤਕਨੀਕਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਹਨ। JavaScript ਚਲਾਉਣ ਲਈ, ਜ਼ਿਆਦਾਤਰ ਆਧੁਨਿਕ ਵੈੱਬ ਬ੍ਰਾਊਜ਼ਰਾਂ ਵਿੱਚ ਇੱਕ ਇਨ-ਬਿਲਟ JavaScript ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਇੰਜਣ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਫਲ ਵੈਬ ਡਿਵੈਲਪਰ ਬਣਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ JavaScript ਨਾਲ ਨਜਿੱਠਣਾ ਪਵੇਗਾ।
ਤੁਹਾਨੂੰ ਅੱਜ ਜਾਂ ਕੱਲ੍ਹ ਇਸ ਨਾਲ ਨਜਿੱਠਣਾ ਪਵੇਗਾ। ਕਿਉਂ ਨਾ ਸਮੇਂ ਤੋਂ ਪਹਿਲਾਂ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਸਿੱਖੋ ਤਾਂ ਜੋ ਸਮਾਂ ਆਉਣ 'ਤੇ ਤੁਸੀਂ ਤਿਆਰ ਰਹੋ?
ਇਹ ਉਹ ਹੈ ਜੋ ਤੁਸੀਂ ਇਸ ਸੈਸ਼ਨ ਵਿੱਚ ਸਿੱਖੋਗੇ। ਇਹ ਦੱਸਦਾ ਹੈ ਕਿ ਤੁਹਾਡੀ JavaScript ਨੂੰ ਪਾਲਿਸ਼ ਕਰਕੇ ਆਪਣੇ ਸਾਥੀ ਵੈੱਬ ਡਿਵੈਲਪਰਾਂ ਤੋਂ ਇੱਕ ਕਦਮ ਅੱਗੇ ਕਿਵੇਂ ਰਹਿਣਾ ਹੈ।
ਚੱਲੀਏ!
1. ਆਪਣੇ ਬੁਨਿਆਦੀ ਗਿਆਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰੋ
ਮੈਂ ਅਸਲ ਵਿੱਚ ਇੱਕ ਬੁਨਿਆਦੀ ਵਿਚਾਰ ਅਤੇ ਕਥਨ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਾਂਗਾ ਜੋ ਤੁਸੀਂ ਇੱਕ ਜਵਾਨ ਹੋਣ ਤੋਂ ਬਾਅਦ ਸੁਣਿਆ ਹੈ। ਬੁਨਿਆਦੀ ਗੱਲਾਂ ਸਿੱਖੋ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਅਮਲ ਵਿੱਚ ਲਿਆਓ। ਕਈ ਵਾਰ, ਤੁਸੀਂ ਕੋਡਿੰਗ ਦੇ ਨਾਲ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰ ਰਹੇ ਹੋਵੋਗੇ, ਪਰ ਤੁਸੀਂ ਭੁੱਲ ਜਾਓਗੇ ਕਿ ਇਸਦੇ ਲਈ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਹੈ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਐਰੇ ਨੂੰ ਕੱਟਣਾ। ਜਦੋਂ ਤੁਸੀਂ JavaScript ਕੋਡ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਗਲਤੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ, ਬਹੁਤ ਸਾਰੀਆਂ ਵਾਧੂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਕੰਮ ਕਰਨਾ ਬੰਦ ਕਰ ਦਿੰਦੀਆਂ ਹਨ।
ਇਹ ਇੱਕ ਸਿੰਗਲ ਕੌਲਨ ਜਾਂ ਉਲਟ ਕਾਮੇ ਕਾਰਨ ਹੋ ਸਕਦਾ ਹੈ। ਇਹ ਚੀਜ਼ਾਂ ਮੂਲ ਸਿਧਾਂਤਾਂ ਦੀ ਸਮਝ ਦੀ ਘਾਟ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਵਾਪਰਦੀਆਂ ਹਨ। ਇੱਕ ਸਿੰਗਲ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਕਈ ਵਾਰ, ਇੱਕ ਬੁਨਿਆਦੀ ਲੂਪ ਜਿਵੇਂ ਕਿ ਲਈ, ਜੋ, ਜਾਂ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ। ਲੂਪਸ ਸਭ ਤੋਂ ਬੁਨਿਆਦੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਨਿਰਮਾਣਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਨ।
ਜੇਕਰ ਤੁਸੀਂ ਲੂਪਿੰਗ ਅਤੇ ਹੋਰ ਬੁਨਿਆਦੀ ਗੱਲਾਂ ਤੋਂ ਅਣਜਾਣ ਹੋ ਤਾਂ ਇਹ ਕੋਡ ਕਰਨਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਹੈ ਅਤੇ ਕਿਸੇ ਫਰਮ ਲਈ ਕੰਮ ਕਰਨ ਦਾ ਮੌਕਾ ਵੀ ਹੈ। ਤੁਹਾਡੀਆਂ ਬੁਨਿਆਦੀ ਗੱਲਾਂ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਉਹ ਇੱਕ ਠੋਸ ਬੁਨਿਆਦ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ ਜਿਸ 'ਤੇ ਹੱਲ ਦੇ ਗੁੰਝਲਦਾਰ ਤਰਕ ਅਤੇ ਵੱਕਾਰ ਨੂੰ ਵਿਕਸਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
2. ਇੱਕ ਵਸਤੂ-ਅਧਾਰਿਤ ਰਣਨੀਤੀ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਵਿਧੀ ਅੱਜ ਸਭ ਤੋਂ ਮਸ਼ਹੂਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਪਹੁੰਚ ਹੈ। ਵਸਤੂ-ਮੁਖੀ ਪਹੁੰਚ, ਜੋ ਕਿ C++ ਨਾਲ ਸ਼ੁਰੂ ਹੋਈ ਸੀ, ਉਸ ਸਮੇਂ ਤੋਂ ਬਹੁਤ ਪ੍ਰਸਿੱਧੀ ਵਿੱਚ ਵਾਧਾ ਹੋਇਆ ਹੈ। ਅੱਜ, ਸਾਰੀਆਂ ਮੁੱਖ ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਸਿਰਫ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਵਸਤੂ-ਅਧਾਰਿਤ ਰਣਨੀਤੀ ਉਹ ਹੁੰਦੀ ਹੈ ਜੋ ਕਿਸੇ ਖਾਸ ਵਸਤੂ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੁੰਦੀ ਹੈ।
ਵਸਤੂ ਫਿਰ ਇੱਕ ਬੁਨਿਆਦੀ ਹਸਤੀ ਬਣ ਜਾਂਦੀ ਹੈ। ਇਸ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਫਿਰ ਆਧਾਰ ਦੇ ਤੌਰ 'ਤੇ ਪੰਨੇ 'ਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋੜਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਤੁਸੀਂ ਬਿਨਾਂ ਕਿਸੇ ਫੰਕਸ਼ਨ ਜਾਂ ਆਬਜੈਕਟ ਦੇ ਉੱਪਰ ਤੋਂ ਹੇਠਾਂ ਤੱਕ ਕੋਡ ਬਣਾਉਣ ਦੀ ਰਵਾਇਤੀ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਬਹੁਤ ਜ਼ਿਆਦਾ ਵਿਆਪਕ ਹੈ ਅਤੇ ਕਦੇ ਵੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ। ਕੋਡ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਸਾਨੂੰ ਇੱਕ ਕਾਰਜਸ਼ੀਲ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਜੇਕਰ ਅਸੀਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਵਸਤੂਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।
ਇਸ ਲਈ, ਸ਼ੁਰੂਆਤ ਵਿੱਚ, ਆਪਣੇ ਵਿਆਪਕ ਕੋਡ ਨੂੰ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਕੋਡ ਵਿੱਚ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਅਤੇ ਹਮੇਸ਼ਾ ਆਪਣੇ ਕੋਡ ਨੂੰ ਇੱਕ ਵਸਤੂ-ਅਧਾਰਿਤ ਸ਼ੈਲੀ ਵਿੱਚ ਲਿਖੋ। ਜਦੋਂ ਤੁਸੀਂ ਦੂਜੇ ਲੋਕਾਂ ਦੇ ਕੋਡ ਦਾ ਅਧਿਐਨ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਲਗਾਤਾਰ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਤਕਨੀਕਾਂ ਨੂੰ ਦੇਖ ਰਹੇ ਹੋਵੋਗੇ। ਜੇਕਰ ਤੁਸੀਂ JavaScript ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਹ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਇਸ 'ਤੇ ਹੱਥ ਪਾਉਂਦੇ ਹੋ।
3. ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਭਾਵੇਂ ਉਹ ਛੋਟੇ ਹੋਣ
ਇੱਕ ਕਾਰਜਸ਼ੀਲ ਪਹੁੰਚ ਨਾਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਜਾਣ ਦਾ ਇੱਕ ਸ਼ਾਨਦਾਰ ਤਰੀਕਾ ਹੈ. ਕਿਉਂ? ਇਹ ਤੁਹਾਡੇ ਸੌਫਟਵੇਅਰ ਨੂੰ ਉਹਨਾਂ ਮੈਡਿਊਲਾਂ ਵਿੱਚ ਵੱਖ ਕਰਦਾ ਹੈ ਜੋ ਇਕੱਠੇ ਕੰਮ ਕਰਦੇ ਹਨ ਪਰ ਫਿਰ ਵੀ ਇੱਕ ਦੂਜੇ ਤੋਂ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ। ਤੁਹਾਨੂੰ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਮੈਂ ਤੁਹਾਨੂੰ ਇੱਕ ਉਦਾਹਰਣ ਦਿੰਦਾ ਹਾਂ।
ਪੂਰਨ ਅੰਕਾਂ ਦਾ ਰੂਟ ਮੀਨ ਵਰਗ ਇੱਕ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗਿਣਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਪੂਰਨ ਅੰਕਾਂ ਦਾ ਵਰਗ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਉਹਨਾਂ ਦੇ ਮੱਧਮਾਨ ਦੀ ਗਣਨਾ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਫਿਰ ਮੱਧਮਾਨ ਦੇ ਵਰਗ ਮੂਲ ਦੀ ਗਣਨਾ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਤਿੰਨ ਪੜਾਅ ਹਨ. ਨਤੀਜੇ ਵਜੋਂ, ਅਸੀਂ ਤਿੰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਨਿਯੁਕਤ ਕਰ ਸਕਦੇ ਹਾਂ। ਪਰ, ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਇਹ ਸਾਰੇ ਫੰਕਸ਼ਨ ਆਪਸ ਵਿੱਚ ਜੁੜੇ ਹੋਏ ਹਨ। ਇੱਕ ਦਾ ਆਉਟਪੁੱਟ ਦੂਜੇ ਨੂੰ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਅਸੀਂ ਅੰਤਮ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ।
ਚਲੋ ਇਹ ਦਿਖਾਵਾ ਕਰੀਏ ਕਿ ਤਿੰਨ ਫੰਕਸ਼ਨਾਂ ਦੀ ਬਜਾਏ, ਤੁਹਾਨੂੰ ਕਈ ਕਾਰਕਾਂ ਦੇ ਅਧਾਰ ਤੇ RMS ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਬਸ ਇੱਕ ਦੀ ਲੋੜ ਹੈ। ਅੰਤਮ ਹੱਲ, ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਗਲਤ ਹੈ. ਤੁਹਾਡੇ ਲਈ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨਾ ਕਾਫ਼ੀ ਮੁਸ਼ਕਲ ਹੋਵੇਗਾ ਕਿ ਇਸ ਸਮੇਂ ਇੰਨੇ ਵੱਡੇ ਸਮਾਗਮ ਵਿੱਚ ਕੀ ਗਲਤ ਹੋਇਆ ਹੈ।
ਦੂਜੇ ਪਾਸੇ, ਤਿੰਨ ਛੋਟੇ ਫੰਕਸ਼ਨ ਹੋਣ ਨਾਲ, ਤੁਹਾਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲੇਗੀ. ਨਤੀਜੇ ਵਜੋਂ, ਭਾਵੇਂ ਫੰਕਸ਼ਨ ਮਾਮੂਲੀ ਹਨ, ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਵੱਖਰੇ ਕੋਡ ਮੋਡੀਊਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਕਰੋ। ਇਹ ਤਕਨੀਕ ਤੁਹਾਨੂੰ ਜਾਦੂ ਵਾਂਗ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਮਾਹਿਰ ਬਣਨ ਵਿੱਚ ਮਦਦ ਕਰੇਗੀ।
ਹੁਣ, ਆਓ ਕੁਝ JavaScript ਕੋਡਿੰਗ ਸੁਝਾਅ ਵੇਖੀਏ।
4. == ਦੀ ਬਜਾਏ, === ਦੀ ਵਰਤੋਂ ਕਰੋ
JavaScript ਵਿੱਚ, ਦੋ ਤਰ੍ਹਾਂ ਦੇ ਸਮਾਨਤਾ ਓਪਰੇਟਰ ਹਨ: ਸਖਤ ਸਮਾਨਤਾ ਓਪਰੇਟਰ === ਅਤੇ !==, ਅਤੇ ਗੈਰ-ਸਖਤ ਸਮਾਨਤਾ ਓਪਰੇਟਰ == ਅਤੇ !=। ਤੁਲਨਾ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਹਮੇਸ਼ਾ ਸਹੀ ਸਮਾਨਤਾ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। == ਅਤੇ != ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਹਾਲਾਂਕਿ, ਤੁਹਾਨੂੰ ਵੱਖਰੀਆਂ ਕਿਸਮਾਂ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਸਮੱਸਿਆਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਵੇਗਾ।
ਜਦੋਂ ਤੁਸੀਂ ਤੁਲਨਾ ਕਰ ਰਹੇ ਮੁੱਲਾਂ ਦੀਆਂ ਕਿਸਮਾਂ ਵੱਖਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ, ਤਾਂ ਗੈਰ-ਸਖਤ ਓਪਰੇਟਰ ਉਹਨਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਜ਼ਬਰਦਸਤੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਗੇ, ਜਿਸ ਨਾਲ ਅਚਾਨਕ ਨਤੀਜੇ ਨਿਕਲ ਸਕਦੇ ਹਨ।
5. JSLint ਦੀ ਵਰਤੋਂ ਕਰੋ
ਡਗਲਸ ਕਰੌਕਫੋਰਡ ਨੇ JSLint, ਇੱਕ ਡੀਬਗਰ ਬਣਾਇਆ। ਬਸ ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਬਾਕਸ ਵਿੱਚ ਪਾਓ, ਅਤੇ ਇਹ ਕਿਸੇ ਵੀ ਬੱਗ ਜਾਂ ਖਾਮੀਆਂ ਲਈ ਇਸ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਸਕੈਨ ਕਰੇਗਾ।
JSLint ਇੱਕ JavaScript ਸਰੋਤ ਫਾਈਲ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਕੋਈ ਸਮੱਸਿਆ ਲੱਭੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਹ ਸਮੱਸਿਆ ਦੇ ਵਰਣਨ ਅਤੇ ਸਰੋਤ ਦੇ ਅੰਦਰ ਇੱਕ ਅਨੁਮਾਨਿਤ ਸਥਿਤੀ ਦੇ ਨਾਲ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਦਾ ਹੈ। ਇਹ ਮੁੱਦਾ ਹਮੇਸ਼ਾ ਇੱਕ ਸਿੰਟੈਕਟਿਕ ਗਲਤੀ ਨਹੀਂ ਹੁੰਦਾ, ਹਾਲਾਂਕਿ ਇਹ ਅਕਸਰ ਹੁੰਦਾ ਹੈ।
JSLint ਸ਼ੈਲੀ ਦੇ ਨਿਯਮਾਂ ਅਤੇ ਢਾਂਚਾਗਤ ਮੁੱਦਿਆਂ ਦੋਵਾਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਤੁਹਾਡਾ ਸੌਫਟਵੇਅਰ ਸਹੀ ਹੈ। ਇਹ ਸਮੱਸਿਆਵਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਵਿੱਚ ਸਹਾਇਤਾ ਲਈ ਅੱਖਾਂ ਦੀ ਇੱਕ ਹੋਰ ਜੋੜੀ ਜੋੜਦਾ ਹੈ। ਕਿਸੇ ਸਕ੍ਰਿਪਟ 'ਤੇ ਸਾਈਨ ਆਫ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ JSLint ਰਾਹੀਂ ਚਲਾਓ ਕਿ ਤੁਸੀਂ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਕੀਤੀ ਹੈ।
6. ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਤੁਹਾਡੇ ਪੰਨੇ ਦੇ ਹੇਠਾਂ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ
ਉਪਭੋਗਤਾ ਦਾ ਮੁੱਖ ਉਦੇਸ਼ ਪੰਨੇ ਨੂੰ ਜਿੰਨੀ ਜਲਦੀ ਹੋ ਸਕੇ ਲੋਡ ਕਰਨਾ ਹੈ। ਬ੍ਰਾਊਜ਼ਰ ਇੱਕ ਸਕ੍ਰਿਪਟ ਨੂੰ ਲੋਡ ਕਰਨਾ ਜਾਰੀ ਨਹੀਂ ਰੱਖ ਸਕਦਾ ਜਦੋਂ ਤੱਕ ਪੂਰੀ ਫਾਈਲ ਲੋਡ ਨਹੀਂ ਹੋ ਜਾਂਦੀ। ਨਤੀਜੇ ਵਜੋਂ, ਉਪਭੋਗਤਾ ਨੂੰ ਕਿਸੇ ਵੀ ਪ੍ਰਗਤੀ ਨੂੰ ਦੇਖਣ ਲਈ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਉਡੀਕ ਕਰਨੀ ਪਵੇਗੀ.
ਜੇ ਤੁਹਾਡੇ ਕੋਲ JS ਫਾਈਲਾਂ ਹਨ ਜੋ ਕੇਵਲ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਵਾਰ ਇੱਕ ਬਟਨ ਦਬਾਉਣ ਤੋਂ ਬਾਅਦ), ਉਹਨਾਂ ਨੂੰ ਕਲੋਜ਼ਿੰਗ ਬਾਡੀ ਟੈਗ ਤੋਂ ਠੀਕ ਪਹਿਲਾਂ, ਪੰਨੇ ਦੇ ਹੇਠਲੇ ਪਾਸੇ ਰੱਖੋ। ਇਹ ਬਿਨਾਂ ਸ਼ੱਕ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸ ਹੈ।
7. ਸਤਰ ਬਣਾਉਣ ਦਾ ਸਭ ਤੋਂ ਤੇਜ਼ ਤਰੀਕਾ
ਜਦੋਂ ਤੁਹਾਨੂੰ ਕਿਸੇ ਐਰੇ ਜਾਂ ਵਸਤੂ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਲੂਪ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਹਮੇਸ਼ਾ ਲੂਪ ਸਟੇਟਮੈਂਟ ਲਈ ਆਪਣੇ ਭਰੋਸੇਮੰਦ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ। ਹੱਥ ਵਿੱਚ ਕੰਮ ਲਈ ਸਭ ਤੋਂ ਤੇਜ਼ ਹੱਲ ਦੇ ਨਾਲ ਆਉਣ ਲਈ ਆਪਣੀ ਕਲਪਨਾ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਮੈਂ ਤੁਹਾਡੇ ਲਈ ਨੰਬਰ ਲਿਆਉਣ ਨਹੀਂ ਜਾ ਰਿਹਾ ਹਾਂ; ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਮੇਰੇ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ ਹੋਵੇਗਾ (ਜਾਂ ਆਪਣੇ ਲਈ ਟੈਸਟ ਕਰੋ)।
ਇਹ ਹੁਣ ਤੱਕ ਦੀ ਸਭ ਤੋਂ ਤੇਜ਼ ਤਕਨੀਕ ਹੈ।
8. ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਇੱਕ ਟਿੱਪਣੀ ਸ਼ਾਮਲ ਕਰੋ
ਇਹ ਪਹਿਲਾਂ ਤਾਂ ਬੇਕਾਰ ਜਾਪ ਸਕਦਾ ਹੈ, ਪਰ ਮੇਰੇ 'ਤੇ ਭਰੋਸਾ ਕਰੋ ਜਦੋਂ ਮੈਂ ਇਹ ਕਹਾਂ ਕਿ ਤੁਹਾਨੂੰ ਜਿੰਨੀ ਵਾਰ ਹੋ ਸਕੇ ਆਪਣੇ ਕੋਡ 'ਤੇ ਟਿੱਪਣੀ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਜੇ ਤੁਸੀਂ ਮਹੀਨਿਆਂ ਬਾਅਦ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹੋ ਅਤੇ ਆਪਣੀ ਅਸਲ ਵਿਚਾਰ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਯਾਦ ਨਹੀਂ ਕਰ ਸਕਦੇ ਤਾਂ ਕੀ ਹੋਵੇਗਾ?
ਉਦੋਂ ਕੀ ਜੇ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਤੁਹਾਡੇ ਕਿਸੇ ਸਹਿਕਰਮੀ ਦੁਆਰਾ ਅਪਡੇਟ ਕੀਤਾ ਜਾਣਾ ਹੈ? ਤੁਹਾਡੇ ਕੋਡ ਦੇ ਮਹੱਤਵਪੂਰਨ ਖੇਤਰਾਂ 'ਤੇ ਹਮੇਸ਼ਾ ਟਿੱਪਣੀ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ।
9. ਟੈਂਪਲੇਟ ਲਿਟਰਲ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਡਬਲ ਜਾਂ ਸਿੰਗਲ ਕੋਟਸ ਨਾਲ ਬਣਾਈਆਂ ਗਈਆਂ ਸਤਰਾਂ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਬਹੁਤ ਹਨ। ਉਹਨਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਬਹੁਤ ਸੌਖਾ ਬਣਾਉਣ ਲਈ, ਤੁਸੀਂ ਆਪਣੀਆਂ ਕੁਝ ਸਤਰਾਂ ਨੂੰ ਟੈਂਪਲੇਟ ਲਿਟਰਲ ਨਾਲ ਬਦਲਣ ਦੀ ਚੋਣ ਕਰ ਸਕਦੇ ਹੋ।
ਬੈਕਟਿਕ ਅੱਖਰ (') ਦੀ ਵਰਤੋਂ ਟੈਂਪਲੇਟ ਲਿਟਰਲ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਦੇ ਕਈ ਫਾਇਦੇ ਹਨ। ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਸਮੀਕਰਨਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਜਾਂ ਮਲਟੀ-ਲਾਈਨ ਸਤਰ ਬਣਾਉਣ ਲਈ ਵਰਤ ਸਕਦੇ ਹੋ।
ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਸਿੰਗਲ ਜਾਂ ਡਬਲ ਕੋਟਸ ਦੇ ਨਾਲ ਬਣਾਈ ਗਈ ਇੱਕ ਪਰੰਪਰਾਗਤ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਦੇ ਉਲਟ, ਸਾਨੂੰ ਵਾਰ-ਵਾਰ ਸਾਡੇ ਟੈਂਪਲੇਟ ਲਿਟਰਲ ਦੇ ਅੰਦਰ ਅਤੇ ਬਾਹਰ ਜਾਣ ਦੀ ਲੋੜ ਨਹੀਂ ਸੀ। ਇਹ ਟਾਈਪਿੰਗ ਦੀਆਂ ਗਲਤੀਆਂ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ ਅਤੇ ਸਾਨੂੰ ਕਲੀਨਰ ਕੋਡ ਲਿਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
10. ਦੁਹਰਾਓ ਅਤੇ ਲੂਪਸ ਦੇ … ਲਈ
ਇਟਰੇਟਰ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਉਹ ਆਬਜੈਕਟ ਹੁੰਦੇ ਹਨ ਜੋ ਕਿਸੇ ਆਬਜੈਕਟ ਨੂੰ ਵਾਪਸ ਕਰਨ ਲਈ ਅਗਲੀ() ਵਿਧੀ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਨ ਜੋ ਇੱਕ ਕ੍ਰਮ ਵਿੱਚ ਅਗਲੇ ਮੁੱਲ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ ਅਤੇ ਨਾਲ ਹੀ ਸਹੀ ਜਾਂ ਗਲਤ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਹੋਰ ਮੁੱਲ ਬਚੇ ਹਨ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਇਟਰੇਟਰ ਪ੍ਰੋਟੋਕੋਲ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਆਪਣੇ ਖੁਦ ਦੇ ਇਟਰੇਟਰ ਆਬਜੈਕਟ ਬਣਾ ਸਕਦੇ ਹੋ।
JavaScript ਵਿੱਚ ਕੁਝ ਬਿਲਟ-ਇਨ ਇਟਰੇਟਰ ਹਨ, ਜਿਵੇਂ ਕਿ ਸਟ੍ਰਿੰਗ, ਐਰੇ, ਮੈਪ, ਅਤੇ ਹੋਰ। ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ ਲੂਪਸ ਦੇ … ਲਈ ਵਰਤ ਸਕਦੇ ਹੋ। ਜਦੋਂ ਲੂਪਸ ਲਈ ਸਾਧਾਰਨ ਨਾਲ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਹ ਵਧੇਰੇ ਸੰਖੇਪ ਅਤੇ ਘੱਟ ਗਲਤੀ-ਸੰਭਾਵੀ ਹੈ। ਸਾਨੂੰ ਇੱਕ for…of ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਰੇ ਦੀ ਪੂਰੀ ਲੰਬਾਈ ਜਾਂ ਮੌਜੂਦਾ ਸੂਚਕਾਂਕ ਦਾ ਟਰੈਕ ਰੱਖਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਨੇਸਟਡ ਲੂਪਸ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਕੋਡ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ।
11. ਨਵੀਂ ਵਸਤੂ() ਦੀ ਬਜਾਏ {} ਦੀ ਵਰਤੋਂ ਕਰੋ
JavaScript ਵਿੱਚ, ਤੁਸੀਂ ਕਈ ਤਰੀਕਿਆਂ ਨਾਲ ਵਸਤੂਆਂ ਬਣਾ ਸਕਦੇ ਹੋ। ਨਵੇਂ ਕੰਸਟਰਕਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਜਿਵੇਂ ਕਿ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਇੱਕ ਵਧੇਰੇ ਰਵਾਇਤੀ ਤਰੀਕਾ ਹੈ। ਇਸ ਰਣਨੀਤੀ ਨੂੰ, ਦੂਜੇ ਪਾਸੇ, "ਮਾੜੀ ਅਭਿਆਸ" ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।
ਇਹ ਵਿਨਾਸ਼ਕਾਰੀ ਨਹੀਂ ਹੈ, ਪਰ ਇਹ ਥੋੜਾ ਸ਼ਬਦੀ ਅਤੇ ਵਿਲੱਖਣ ਹੈ। ਮੈਂ ਆਬਜੈਕਟ ਸ਼ਾਬਦਿਕ ਤਕਨੀਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਬਜਾਏ ਪ੍ਰਸਤਾਵਿਤ ਕਰਦਾ ਹਾਂ.
12. ਆਪਣੇ ਕੋਡ ਵਿੱਚ let ਅਤੇ const ਪਾਉਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ
ਅਸੀਂ ਸਥਾਨਕ ਵੇਰੀਏਬਲ ਬਣਾਉਣ ਲਈ let ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਉਹਨਾਂ ਦੇ ਆਪਣੇ ਬਲਾਕ ਲਈ ਸਕੋਪ ਕੀਤੇ ਗਏ ਹਨ। ਅਸੀਂ ਸਥਾਨਕ ਬਲਾਕ-ਸਕੋਪ ਵਾਲੇ ਵੇਰੀਏਬਲ ਬਣਾਉਣ ਲਈ const ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਬਦਲੇ ਨਹੀਂ ਜਾ ਸਕਦੇ।
ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਦੇ ਸਮੇਂ, ਤੁਹਾਨੂੰ ਲਾਗੂ ਹੋਣ 'ਤੇ let ਅਤੇ const ਕੀਵਰਡਸ ਦੀ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਯਾਦ ਰੱਖੋ ਕਿ const ਕੀਵਰਡ ਸਿਰਫ਼ ਮੁੜ ਅਸਾਈਨਮੈਂਟ ਨੂੰ ਅਯੋਗ ਕਰਦਾ ਹੈ। ਇਹ ਵੇਰੀਏਬਲ ਨੂੰ ਬਦਲਣਯੋਗ ਨਹੀਂ ਬਣਾਉਂਦਾ, ਜਾਂ ਤਾਂ.
13. eval() ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਨਹੀਂ ਹੈ
eval() ਵਿਧੀ, ਅਣਜਾਣ ਲੋਕਾਂ ਲਈ, ਸਾਨੂੰ JavaScript ਦੇ ਕੰਪਾਈਲਰ ਤੱਕ ਪਹੁੰਚ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਇੱਕ ਸਟਰਿੰਗ ਦੇ ਨਤੀਜੇ ਨੂੰ ਇੱਕ ਇਨਪੁਟ () ਦੇ ਤੌਰ 'ਤੇ ਸਪਲਾਈ ਕਰਨ ਲਈ eval ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ।
ਇਹ ਨਾ ਸਿਰਫ਼ ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਹੌਲੀ ਕਰੇਗਾ, ਪਰ ਇਹ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਸੁਰੱਖਿਆ ਚਿੰਤਾ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਪਾਸ ਕੀਤੇ ਟੈਕਸਟ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਅਧਿਕਾਰ ਦਿੰਦਾ ਹੈ। ਹਰ ਕੀਮਤ 'ਤੇ ਇਸ ਤੋਂ ਬਚੋ!
14. ਸਪ੍ਰੈਡ ਆਪਰੇਟਰ ਕੰਮ ਆਉਂਦਾ ਹੈ
ਕੀ ਤੁਹਾਨੂੰ ਕਦੇ ਇੱਕ ਐਰੇ ਵਿੱਚ ਸਾਰੀਆਂ ਆਈਟਮਾਂ ਨੂੰ ਵਿਅਕਤੀਗਤ ਤੱਤਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਕਿਸੇ ਹੋਰ ਫੰਕਸ਼ਨ ਵਿੱਚ ਭੇਜਣ ਦੀ ਲੋੜ ਹੈ, ਜਾਂ ਕੀ ਤੁਹਾਨੂੰ ਇੱਕ ਐਰੇ ਤੋਂ ਦੂਜੇ ਵਿੱਚ ਸਾਰੇ ਮੁੱਲ ਪਾਉਣ ਦੀ ਲੋੜ ਹੈ? ਇਹ ਬਿਲਕੁਲ ਉਹੀ ਹੈ ਜੋ ਸਪ੍ਰੈਡ ਓਪਰੇਟਰ (…) ਸਾਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ।
15. ਉਡੀਕ ਕਰੋ ਅਤੇ ਅਸਿੰਕ ਕਰੋ
async ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਅਸਿੰਕਰੋਨਸ ਫੰਕਸ਼ਨ ਬਣਾਓ, ਜੋ ਹਮੇਸ਼ਾ ਇੱਕ ਵਾਅਦਾ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਾਂ ਤਾਂ ਸਪੱਸ਼ਟ ਜਾਂ ਅਪ੍ਰਤੱਖ ਰੂਪ ਵਿੱਚ।
ਵਾਅਦਿਆਂ ਨੂੰ ਵਾਪਸ ਕਰਨ ਦਾ ਹੱਲ ਪੂਰਾ ਹੋਣ ਤੱਕ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਰੋਕਣ ਲਈ ਉਡੀਕ ਕੀਵਰਡ ਨੂੰ ਅਸਿੰਕ੍ਰੋਨਸ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਤੁਹਾਡੇ ਅਸਿੰਕ ਫੰਕਸ਼ਨ ਤੋਂ ਬਾਹਰ, ਕੋਡ ਆਮ ਤੌਰ 'ਤੇ ਚੱਲਦਾ ਰਹੇਗਾ।
16. Javascript ਵਿੱਚ includes() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ
JavaScript ਵਿੱਚ, includes() ਫੰਕਸ਼ਨ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਇੱਕ ਸਤਰ ਵਿੱਚ ਸਪਲਾਈ ਕੀਤੇ ਅੱਖਰ ਹਨ ਜਾਂ ਕੀ ਇੱਕ ਐਰੇ ਵਿੱਚ ਨਿਰਧਾਰਤ ਤੱਤ ਸ਼ਾਮਲ ਹਨ।
ਜੇਕਰ ਸਤਰ ਜਾਂ ਤੱਤ ਖੋਜਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਇਹ ਵਿਧੀ ਸਹੀ ਵਾਪਸ ਆਉਂਦੀ ਹੈ; ਨਹੀਂ ਤਾਂ, ਇਹ ਗਲਤ ਵਾਪਸ ਆਉਂਦਾ ਹੈ। ਇਹ ਵਰਣਨ ਯੋਗ ਹੈ ਕਿ ਸਟ੍ਰਿੰਗਸ contains() ਫੰਕਸ਼ਨ ਕੇਸ-ਸੰਵੇਦਨਸ਼ੀਲ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਕੇਸ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ ਇੱਕ ਸਤਰ ਨਾਲ ਮੇਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਪਹਿਲਾਂ ਟਾਰਗੇਟ ਟੈਕਸਟ ਨੂੰ ਛੋਟਾ ਕਰੋ।
17. Splice ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਐਰੇ ਤੋਂ ਆਈਟਮਾਂ ਨੂੰ ਹਟਾਓ
ਇੱਕ ਐਰੇ ਤੋਂ ਇੱਕ ਆਈਟਮ ਨੂੰ ਹਟਾਉਣ ਲਈ, ਮੈਂ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਡਿਲੀਟ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਦੇਖਿਆ ਹੈ। ਇਹ ਗਲਤ ਹੈ ਕਿਉਂਕਿ, ਆਬਜੈਕਟ ਨੂੰ ਮਿਟਾਉਣ ਦੀ ਬਜਾਏ, ਡਿਲੀਟ ਵਿਧੀ ਇਸਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਨਾਲ ਬਦਲ ਦਿੰਦੀ ਹੈ।
JavaScript ਵਿੱਚ ਇਸਦੇ ਮੁੱਲ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਐਰੇ ਤੋਂ ਇੱਕ ਐਲੀਮੈਂਟ ਨੂੰ ਹਟਾਉਣ ਦਾ ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ ਹੈ indexOf() ਫੰਕਸ਼ਨ ਨੂੰ ਐਰੇ ਵਿੱਚ ਉਸ ਮੁੱਲ ਦਾ ਸੂਚਕਾਂਕ ਨੰਬਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਣਾ, ਫਿਰ splice() ਵਿਧੀ ਨਾਲ ਉਸ ਸੂਚਕਾਂਕ ਮੁੱਲ ਨੂੰ ਮਿਟਾਉਣਾ ਹੈ।
18. ਐਰੋ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਐਰੋ ਫੰਕਸ਼ਨ ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਜੋ ਹੁਣੇ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ ਹੈ।
ਉਹਨਾਂ ਕੋਲ ਫਾਇਦਿਆਂ ਦਾ ਬੋਟਲੋਡ ਹੈ. ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਉਹ JavaScript ਦੇ ਕਾਰਜਸ਼ੀਲ ਹਿੱਸਿਆਂ ਨੂੰ ਵਧੇਰੇ ਦਿੱਖ ਰੂਪ ਵਿੱਚ ਆਕਰਸ਼ਕ ਅਤੇ ਲਿਖਣ ਵਿੱਚ ਆਸਾਨ ਬਣਾਉਂਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਐਰੋ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਇਸ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਸੰਖੇਪ ਬਣਾਉਂਦਾ ਹੈ।
19. ਡਿਸਟ੍ਰਕਚਰਿੰਗ ਨਾਲ, ਤੁਸੀਂ ਤੇਜ਼ੀ ਨਾਲ ਵੇਰੀਏਬਲ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ
ਪਹਿਲਾਂ ਇਸ ਪੋਸਟ ਵਿੱਚ, ਅਸੀਂ JavaScript ਵਿੱਚ ਫੈਲਣ ਵਾਲੇ ਆਪਰੇਟਰ ਬਾਰੇ ਸਿੱਖਿਆ ਸੀ। ਵਿਨਾਸ਼ਕਾਰੀ ਵਿਨਾਸ਼ਕਾਰੀ ਦੇ ਸਮਾਨ ਹੈ ਕਿਉਂਕਿ ਇਹ ਐਰੇ ਦੇ ਅੰਦਰ ਮੌਜੂਦ ਡੇਟਾ ਨੂੰ ਵੀ ਅਨਪੈਕ ਕਰਦਾ ਹੈ।
ਅੰਤਰ ਇਹ ਹੈ ਕਿ ਇਹ ਅਨਪੈਕ ਕੀਤੇ ਮੁੱਲ ਵੱਖਰੇ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਇੱਕ ਐਰੇ ਬਣਾਉਣ ਵੇਲੇ ਸਿੰਟੈਕਸ [] ਸ਼ਾਰਟਕੱਟ ਦੇ ਸਮਾਨ ਹੁੰਦਾ ਹੈ। ਬਰੈਕਟ, ਹਾਲਾਂਕਿ, ਇਸ ਵਾਰ ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰ ਦੇ ਖੱਬੇ ਪਾਸੇ ਰੱਖੇ ਗਏ ਹਨ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ।
20. ਕਈ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ
ਕੋਈ ਵੀ ਪ੍ਰਤਿਭਾ ਇਕਸਾਰ ਅਭਿਆਸ ਕਰਦੀ ਹੈ, ਇਸਲਈ ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦ੍ਰਿਸ਼ਾਂ ਨਾਲ ਆਪਣੀ ਕਾਬਲੀਅਤ ਨੂੰ ਨਿਖਾਰਨ ਅਤੇ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਲਈ ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ।
ਪ੍ਰੋਜੈਕਟਾਂ 'ਤੇ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਤੁਸੀਂ ਕਈ ਚੁਣੌਤੀਆਂ ਅਤੇ ਨੁਕਸਾਂ ਦਾ ਅਨੁਭਵ ਕਰੋਗੇ, ਜੋ ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੀ ਮੁਹਾਰਤ ਪ੍ਰਦਾਨ ਕਰਨਗੇ। ਇਸ ਲਈ ਪ੍ਰੋਜੈਕਟਾਂ ਦੇ ਨਾਲ ਆਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਅਤੇ ਤੁਹਾਡੀ ਸਹਾਇਤਾ ਲਈ ਇੰਟਰਨੈਟ 'ਤੇ ਵਿਚਾਰਾਂ ਅਤੇ ਉਦਾਹਰਣਾਂ ਦੀ ਬਹੁਤਾਤ ਹੈ। ਕੋਡ ਵਿਕਸਿਤ ਕਰਨਾ ਜਾਰੀ ਰੱਖੋ, ਅਤੇ ਤੁਹਾਡੀਆਂ ਕਾਬਲੀਅਤਾਂ ਵਿੱਚ ਸੁਧਾਰ ਹੋਵੇਗਾ।
ਸਿੱਟਾ
JavaScript ਵਰਗੀ ਕੰਪਿਊਟਰ ਭਾਸ਼ਾ ਸਿੱਖਣੀ ਮੁਸ਼ਕਲ ਹੋ ਸਕਦੀ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਚੰਗਾ ਪ੍ਰੋਗਰਾਮਰ ਬਣਨ ਅਤੇ ਆਪਣੀ ਪਹਿਲੀ ਨੌਕਰੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਗੰਭੀਰ ਹੋ, ਤਾਂ ਇਹ JavaScript ਸਿੱਖਣ ਦੀਆਂ ਰਣਨੀਤੀਆਂ ਤੁਹਾਡੀ ਸਿੱਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰ ਸਕਦੀਆਂ ਹਨ।
ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਨਿਯਮਤ ਅਧਾਰ 'ਤੇ ਕੋਡਿੰਗ ਦਾ ਅਭਿਆਸ ਕਰਦੇ ਹੋ, ਨਵੇਂ ਵਿਚਾਰਾਂ ਨੂੰ ਸਿੱਖਣ ਵੇਲੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨੋਟਸ ਲਓ, ਅਤੇ ਤੁਹਾਡੇ ਲਈ ਪਹੁੰਚਯੋਗ ਸਾਰੇ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਸਭ ਤੋਂ ਵੱਧ, ਉੱਥੇ ਜਾਓ ਅਤੇ ਮੌਜ-ਮਸਤੀ ਕਰਦੇ ਹੋਏ ਕੋਡਿੰਗ ਸ਼ੁਰੂ ਕਰੋ।
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ