ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ React ਡਿਵੈਲਪਰ ਹੋ ਜਿਸਨੇ ਅਜੇ ਤੱਕ React ਹੁੱਕਾਂ ਬਾਰੇ ਨਹੀਂ ਸਿੱਖਿਆ ਹੈ, ਤਾਂ ਹੁਣ ਇਹ ਸਮਾਂ ਹੈ। ਇਹ ਪੋਸਟ ਵਿਸਥਾਰ ਵਿੱਚ ਇਫੈਕਟ ਰਿਐਕਟ ਹੁੱਕ ਦੀ ਵਰਤੋਂ ਦੁਆਰਾ ਜਾਵੇਗਾ। ਇਹ ਸਵਿਸ ਆਰਮੀ ਚਾਕੂ ਦੇ ਬਰਾਬਰ ਹੁੱਕ ਹੈ। ਇਹ ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਜਦੋਂ ਕੋਈ ਕੰਪੋਨੈਂਟ ਮਾਊਂਟ ਹੁੰਦਾ ਹੈ ਤਾਂ ਡੇਟਾ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ, ਜਦੋਂ ਕੋਈ ਸਟੇਟ ਜਾਂ ਪ੍ਰੋਪ ਬਦਲਦਾ ਹੈ ਤਾਂ ਕੋਡ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ, ਟਾਈਮਰ ਜਾਂ ਅੰਤਰਾਲਾਂ ਨੂੰ ਕਿਵੇਂ ਸੈੱਟ ਕਰਨਾ ਹੈ, ਆਦਿ।
ਇੱਕ useEffect ਦੀ ਵਰਤੋਂ ਬਹੁਤ ਕੁਝ ਉਸ ਚੀਜ਼ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਤੁਸੀਂ ਇੱਕ React ਕੰਪੋਨੈਂਟ ਵਿੱਚ "ਕਰਨ" ਚਾਹੁੰਦੇ ਹੋ ਜੋ JSX (ਕਿਸੇ ਕਿਸਮ ਦਾ ਮਾੜਾ ਪ੍ਰਭਾਵ) ਵਾਪਸ ਨਹੀਂ ਕਰ ਰਿਹਾ ਹੈ। ਤੁਹਾਡੇ ਕੋਲ ਪ੍ਰਤੀ ਭਾਗ ਦੇ ਕਈ ਉਪਯੋਗ ਪ੍ਰਭਾਵ ਵੀ ਹੋ ਸਕਦੇ ਹਨ।
ਇਹ ਸਾਰੀ ਸ਼ਕਤੀ ਇੱਕ ਕੀਮਤ 'ਤੇ ਆਉਂਦੀ ਹੈ: ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਇਹ ਨਹੀਂ ਸਮਝਦੇ ਹੋ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਹ ਉਲਝਣ ਵਾਲਾ ਹੋ ਸਕਦਾ ਹੈ। ਇਸ ਪੋਸਟ ਵਿੱਚ, ਅਸੀਂ ਕਈ ਤਰ੍ਹਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦੇਖਾਂਗੇ ਤਾਂ ਜੋ ਤੁਸੀਂ ਸੰਕਲਪਿਕ ਮਾਡਲ ਨੂੰ ਸਮਝ ਸਕੋ ਅਤੇ ਇਸਨੂੰ ਆਪਣੇ ਖੁਦ ਦੇ ਕੋਡ 'ਤੇ ਲਾਗੂ ਕਰ ਸਕੋ।
ਪ੍ਰਤੀਕ੍ਰਿਆ ਹੁੱਕ - ਇਹ ਕੀ ਹੱਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ?
ਹੁੱਕਾਂ ਨੂੰ ਪਹਿਲਾਂ ਰੀਐਕਟ ਸੰਸਕਰਣ 16.8 ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਹੁਣ ਬਹੁਤ ਸਾਰੇ ਰੀਐਕਟ ਪ੍ਰੋਜੈਕਟਾਂ ਦੁਆਰਾ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਹੁੱਕਸ ਕੰਪੋਨੈਂਟਸ ਦੇ ਵਿਚਕਾਰ ਕੋਡ ਦੁਹਰਾਉਣ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ। ਉਹ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਲਿਖੇ ਗਏ ਹਨ. ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਪ੍ਰਤੀਕਿਰਿਆ ਕਲਾਸਾਂ ਨੂੰ ਛੱਡ ਰਹੀ ਹੈ; ਹੁੱਕ ਸਿਰਫ਼ ਇੱਕ ਵਿਕਲਪਿਕ ਢੰਗ ਹਨ।
ਪ੍ਰਤੀਕ੍ਰਿਆ ਤੁਹਾਨੂੰ ਰਾਜਪੂਰਨ ਤਰਕ ਨਾਲ ਤੇਜ਼ੀ ਨਾਲ ਵਧੀਆ ਭਾਗ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਇਹਨਾਂ ਹਿੱਸਿਆਂ ਨੂੰ ਵੱਖ ਕਰਨਾ ਔਖਾ ਹੈ ਕਿਉਂਕਿ ਕਲਾਸ ਰੀਐਕਟ ਲਾਈਫਸਾਈਕਲ ਤਰੀਕਿਆਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ। ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਰੀਐਕਟ ਹੁੱਕ ਆਉਂਦੇ ਹਨ।
ਉਹ ਤੁਹਾਨੂੰ ਇੱਕ ਹਿੱਸੇ ਨੂੰ ਛੋਟੇ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਵੰਡਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ। ਲਾਈਫਸਾਈਕਲ ਵਿਧੀਆਂ ਦੇ ਆਧਾਰ 'ਤੇ ਕੋਡ ਨੂੰ ਛੋਟੇ ਟੁਕੜਿਆਂ ਵਿੱਚ ਵੰਡਣ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਹੁਣ ਕਾਰਜਸ਼ੀਲਤਾ ਦੇ ਆਧਾਰ 'ਤੇ ਕੋਡ ਨੂੰ ਛੋਟੀਆਂ ਇਕਾਈਆਂ ਵਿੱਚ ਵਿਵਸਥਿਤ ਅਤੇ ਵੱਖ ਕਰ ਸਕਦੇ ਹੋ।
ਯੂਜ਼ ਇਫੈਕਟ ਹੁੱਕ ਕੀ ਹੈ?
ਹੁੱਕਸ ਫੰਕਸ਼ਨ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ES6 ਕਲਾਸਾਂ ਨੂੰ ਲਿਖੇ ਬਿਨਾਂ ਸਟੇਟ ਅਤੇ ਹੋਰ ਪ੍ਰਤੀਕਿਰਿਆ ਸਮਰੱਥਾਵਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ। ਰੀਐਕਟ ਹੁੱਕਸ API ਵਿੱਚ ਇੱਕ ਹੁੱਕ ਹੈ ਜਿਸਨੂੰ useEffect ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਪ੍ਰਤੀਕਿਰਿਆ ਜੀਵਨ ਚੱਕਰਾਂ ਤੋਂ ਜਾਣੂ ਹੋ, ਤਾਂ ਵਰਤੋਂ ਪ੍ਰਭਾਵ ਹੁੱਕ ਦੇ ਸਮਾਨ ਹੈ componentDidMount, componentDidUpdateਹੈ, ਅਤੇ componentWillUnmount ਜੀਵਨ ਚੱਕਰ ਦੇ ਤਰੀਕਿਆਂ ਨੂੰ ਮਿਲਾ ਕੇ।
ਰੀਐਕਟ ਹੁੱਕਸ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਅਨੁਸਾਰ, ਇਸਨੂੰ ES6 ਕਲਾਸ ਕੰਪੋਨੈਂਟ ਜੀਵਨ ਚੱਕਰ ਵਿਧੀਆਂ ਨਾਲ ਕੁਝ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਬਣਾਇਆ ਗਿਆ ਸੀ।
ਸੰਟੈਕਸ
ਪਹਿਲਾ ਆਰਗੂਮੈਂਟ ਇੱਕ ਕਾਲਬੈਕ ਫੰਕਸ਼ਨ ਹੈ, ਜੋ ਕਿ ਹਰੇਕ ਰੈਂਡਰ ਤੋਂ ਬਾਅਦ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਦੂਜਾ ਪੈਰਾਮੀਟਰ ਇੱਕ ਵਿਕਲਪਿਕ ਨਿਰਭਰਤਾ ਐਰੇ ਹੈ ਜੋ ਹੁੱਕ ਨੂੰ ਸਿਰਫ ਤਾਂ ਹੀ ਕਾਲਬੈਕ ਕਰਨ ਲਈ ਨਿਰਦੇਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੇਕਰ ਟਾਰਗੇਟ ਸਥਿਤੀ ਬਦਲਦੀ ਹੈ।
ਹੁੱਕ ਹਰੇਕ ਨਿਰਭਰਤਾ ਦੀਆਂ ਇਤਿਹਾਸਕ ਅਤੇ ਮੌਜੂਦਾ ਸਥਿਤੀਆਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਦੋ ਮੁੱਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦੇ, ਤਾਂ ਹੁੱਕ ਪਹਿਲੇ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਕਾਲਬੈਕ ਨੂੰ ਸੱਦਾ ਦਿੰਦਾ ਹੈ। ਨਿਰਭਰਤਾ ਐਰੇ ਆਮ ਕਾਲਬੈਕ ਵਿਵਹਾਰ ਨੂੰ ਬਦਲਦੇ ਹਨ ਅਤੇ ਗਾਰੰਟੀ ਦਿੰਦੇ ਹਨ ਕਿ ਹੁੱਕ ਕੰਪੋਨੈਂਟ ਸਕੋਪ ਵਿੱਚ ਹੋਰ ਸਾਰੇ ਭਾਗਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਦਾ ਹੈ।
ਮੁੱਢਲੀ ਵਰਤੋਂ
ਇੱਕ ਸੁਨੇਹਾ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ, ਮੈਂ ਉੱਪਰ ਦਿੱਤੇ ਕੋਡ ਨਮੂਨੇ ਵਿੱਚ React useState ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ/ਰਹੀ ਹਾਂ। ਉਸ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਆਪਣਾ ਸੁਨੇਹਾ ਸਟੇਟ ਵੇਰੀਏਬਲ ਲੈਂਦਾ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਸਕ੍ਰੀਨ 'ਤੇ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹਾਂ। ਹਾਲਾਂਕਿ, ਮੈਂ ਹੁਣ ਕੰਪੋਨੈਂਟ ਦੇ ਮਾਊਂਟ ਹੋਣ ਤੋਂ ਇੱਕ ਸਕਿੰਟ ਬਾਅਦ ਸੰਦੇਸ਼ ਨੂੰ ਸੋਧਣ ਲਈ ਪ੍ਰਭਾਵ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ।
ਮੈਂ React ਫਰੇਮਵਰਕ ਤੋਂ useEffect ਨੂੰ ਆਯਾਤ ਕਰਨ ਤੋਂ ਬਾਅਦ useState ਲਾਈਨ ਦੇ ਪਿੱਛੇ ਆਪਣਾ ਪ੍ਰਭਾਵ ਪਾ ਦਿੱਤਾ ਹੈ। ਪ੍ਰਭਾਵ ਨੂੰ ਵਰਤਣ ਲਈ ਪਹਿਲਾ ਪੈਰਾਮੀਟਰ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ। ਜਦੋਂ ਇਹ ਫੰਕਸ਼ਨ ਹੈਂਡਲਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਤੁਹਾਡੇ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕਿਸੇ ਵੀ ਮਾੜੇ ਪ੍ਰਭਾਵਾਂ ਦਾ ਧਿਆਨ ਰੱਖੇਗਾ। ਫੰਕਸ਼ਨ ਇੱਕ ਕਾਲਬੈਕ ਫੰਕਸ਼ਨ ਹੁੰਦਾ ਹੈ ਜਿਸਨੂੰ ਉਦੋਂ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਕੰਪੋਨੈਂਟ ਲਾਈਫਸਾਈਕਲ ਘਟਨਾ ਵਾਪਰਦੀ ਹੈ।
ਇਸਨੂੰ ਕਦੋਂ ਵਰਤਣਾ ਹੈ?
UseEffect ਹੁੱਕ ਕਈ ਸਥਿਤੀਆਂ ਵਿੱਚ ਉਪਯੋਗੀ ਹੋ ਸਕਦਾ ਹੈ। ਹੇਠ ਲਿਖੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਹਨ:
- ਅਸੀਂ ਇਸ ਪੈਰਾਮੀਟਰ ਨੂੰ ਕਲਾਇੰਟ ਸਾਈਡ ਤੋਂ ਬਦਲ ਸਕਦੇ ਹਾਂ ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਸਪਲਾਈ ਕੀਤੀ ਦਲੀਲ ਦੇ ਅਧਾਰ ਤੇ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਪੈਰਾਮੀਟਰ ਨੂੰ ਤਾਜ਼ਾ ਡੇਟਾ ਦੇ ਨਾਲ ਅਪਡੇਟ ਕੀਤੇ ਜਾਣ ਤੋਂ ਬਾਅਦ ਇਸਨੂੰ ਵਾਪਸ ਬੁਲਾਇਆ ਜਾਵੇਗਾ।
- ਜੇਕਰ ਅਸੀਂ ਇੱਕ API ਐਂਡਪੁਆਇੰਟ ਤੋਂ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਕਲਾਇੰਟ-ਸਾਈਡ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਜਦੋਂ ਸਾਡਾ ਕੰਪੋਨੈਂਟ ਰੈਂਡਰ ਹੁੰਦਾ ਹੈ, ਤਾਂ UseEffect ਹੁੱਕ ਨੂੰ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਜਾਂ ਹੈਂਡਲਰ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਕੰਪੋਨੈਂਟ ਸਟੇਟਸ ਵਿੱਚ ਡੇਟਾ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹਨਾਂ ਸਥਿਤੀਆਂ ਨੂੰ ਫਿਰ ਉਪਭੋਗਤਾ ਇੰਟਰਫੇਸ ਭਾਗਾਂ ਵਿੱਚ ਨਿਯੁਕਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
- ਜਦੋਂ ਤੁਹਾਡਾ ਕੰਪੋਨੈਂਟ ਬਾਹਰੀ ਦੁਨੀਆ ਦੇ ਡੇਟਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਅਤੇ ਅਸੀਂ ਇਹ ਯਕੀਨੀ ਨਹੀਂ ਕਰ ਸਕਦੇ ਕਿ ਡੇਟਾ ਆਵੇਗਾ, ਤਾਂ ਸਾਨੂੰ ਪ੍ਰਭਾਵ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ (ਸ਼ਾਇਦ ਸਰਵਰ ਉੱਥੇ ਬੰਦ ਹੈ)। ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਸੁੱਟਣ ਅਤੇ ਹੋਰ ਭਾਗਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਹੋਣ ਤੋਂ ਰੋਕਣ ਦੀ ਬਜਾਏ, ਉਹਨਾਂ ਨੂੰ useEffect ਹੁੱਕ ਵਿੱਚ ਰੱਖੋ।
ਕੇਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਜੇਕਰ ਕੰਪੋਨੈਂਟ ਪਹਿਲੀ ਵਾਰ ਚੱਲਣ ਤੋਂ ਬਾਅਦ ਮੁੜ-ਰੈਂਡਰ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਐਗਜ਼ੀਕਿਊਟ ਨਹੀਂ ਹੋਵੇਗਾ।
ਜਦੋਂ ਵੀ ਕੋਈ ਕੰਪੋਨੈਂਟ ਰੈਂਡਰ ਜਾਂ ਰੀ-ਰੈਂਡਰ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਹਮੇਸ਼ਾ ਚਲਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਪ੍ਰੋਗਰਾਮ ਸਿਰਫ ਇੱਕ ਵਾਰ ਚੱਲਦਾ ਹੈ। ਬਾਅਦ ਵਿੱਚ, ਜੇਕਰ ਪ੍ਰੋਪ ਮੁੱਲ ਬਦਲਦੇ ਹਨ, ਤਾਂ ਚਲਾਓ:
ਅਸਿੰਕਰੋਨਸ ਗਤੀਵਿਧੀਆਂ ਲਈ, ਹਮੇਸ਼ਾ useEffect ਦੀ ਵਰਤੋਂ ਕਰੋ।
useEffect ਕੋਡ ਬਲਾਕ ਤੁਹਾਡੇ ਸਾਥੀ ਡਿਵੈਲਪਰਾਂ ਲਈ ਅਸਿੰਕ੍ਰੋਨਸ ਨੌਕਰੀਆਂ ਦੇ ਸਪੱਸ਼ਟ ਮਾਰਕਰ ਹਨ। UseEffect ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਅਸਿੰਕ੍ਰੋਨਸ ਕੋਡ ਬਣਾਉਣਾ ਸੰਭਵ ਹੈ, ਪਰ ਇਹ "ਪ੍ਰਤੀਕਿਰਿਆ ਵਿਧੀ" ਨਹੀਂ ਹੈ, ਅਤੇ ਇਹ ਗੁੰਝਲਦਾਰਤਾ ਅਤੇ ਗਲਤੀਆਂ ਦੇ ਜੋਖਮ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ।
ਅਸਿੰਕ੍ਰੋਨਸ ਕੋਡ ਲਿਖਣ ਦੀ ਬਜਾਏ useEffect ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜੋ UI ਨੂੰ ਰੋਕ ਸਕਦਾ ਹੈ, React ਭਾਈਚਾਰੇ ਵਿੱਚ ਇੱਕ ਜਾਣੀ-ਪਛਾਣੀ ਤਕਨੀਕ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਿਸ ਤਰੀਕੇ ਨਾਲ React ਟੀਮ ਨੇ ਇੱਕ ਮਾੜਾ ਪ੍ਰਭਾਵ ਕਰਨ ਲਈ ਇਸਨੂੰ ਬਣਾਇਆ ਹੈ।
ਇਸਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਫਾਇਦਾ ਇਹ ਹੈ ਕਿ ਡਿਵੈਲਪਰ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਤੁਰੰਤ ਕੋਡ ਦਾ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹਨ ਜੋ "ਨਿਯੰਤਰਣ ਪ੍ਰਵਾਹ ਤੋਂ ਬਾਹਰ" ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ ਪਹਿਲੇ ਰੈਂਡਰ ਚੱਕਰ ਤੋਂ ਬਾਅਦ ਹੀ ਮਹੱਤਵਪੂਰਨ ਬਣ ਜਾਂਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਬਲਾਕ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਅਤੇ ਹੋਰ ਵੀ ਅਰਥਪੂਰਨ ਕਸਟਮ ਹੁੱਕਾਂ ਵਿੱਚ ਕੱਢਣ ਲਈ ਢੁਕਵੇਂ ਹਨ।
ਇੱਕ ਉਦਾਹਰਣ
ਯੂਜ਼ ਇਫੈਕਟ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਪ੍ਰਤੀ ਸਕਿੰਟ ਇੱਕ ਨੰਬਰ ਵਧਾਓ।
ਸਿੱਟਾ
ਮੇਰੇ ਵਿਚਾਰ ਵਿੱਚ, ਜੇਕਰ ਤੁਸੀਂ ਅਗਲੇ-ਪੱਧਰ ਦੇ ਰੀਐਕਟ ਡਿਵੈਲਪਰ ਬਣਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਮੇਰੇ ਵਿਚਾਰ ਵਿੱਚ, ਅੰਡਰਲਾਈੰਗ ਡਿਜ਼ਾਈਨ ਸਿਧਾਂਤਾਂ ਅਤੇ ਉਪਯੋਗਤਾ ਹੁੱਕ ਦੇ ਵਧੀਆ ਅਭਿਆਸਾਂ ਨੂੰ ਸਮਝਣਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹੁਨਰ ਹੈ।
ਸੰਖੇਪ ਕਰਨ ਲਈ, useEffect Hook ਇੱਕ ਫੰਕਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਲਾਜ਼ਮੀ, ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਪੂਰਾ ਤਰਕ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਨਿਰਭਰਤਾ ਐਰੇ, ਜੋ ਕਿ ਦੂਜਾ ਪੈਰਾਮੀਟਰ ਹੈ, ਨੂੰ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ, ਰਿਟਰਨ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਫਾਈ ਕੋਡ ਲਿਖਣਾ ਵੀ ਜ਼ਰੂਰੀ ਹੈ।
ਸਾਨੂੰ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਦੱਸੋ ਜੇ ਲੇਖ ਮਦਦਗਾਰ ਸੀ।
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ