JavaScript ਐਰੇ ਕਲੋਨਿੰਗ ਅਤੇ ਪਰਿਵਰਤਨ ਨੂੰ ਸਮਝਣਾ
ਕਲੋਨਿੰਗ ਐਰੇ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇੱਕ ਪ੍ਰਸਿੱਧ ਗਤੀਵਿਧੀ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਮੂਲ ਡੇਟਾ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕੀਤੇ ਬਿਨਾਂ ਮੂਲ ਐਰੇ ਦੇ ਡੁਪਲੀਕੇਟ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਹਾਲਾਂਕਿ, ਸਿੱਧੀਆਂ ਕਲੋਨਿੰਗ ਤਕਨੀਕਾਂ JavaScript ਵਸਤੂਆਂ ਦੇ ਕੰਮ ਕਰਨ ਦੇ ਤਰੀਕੇ ਦੇ ਕਾਰਨ ਇਰਾਦੇ ਅਨੁਸਾਰ ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਦੀਆਂ। ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਅਕਸਰ ਅਜਿਹੇ ਦ੍ਰਿਸ਼ਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਕਾਪੀ ਕੀਤੇ ਗਏ ਐਰੇ ਵਿੱਚ ਕੀਤੀਆਂ ਸੋਧਾਂ ਵੀ ਅਸਲ ਐਰੇ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀਆਂ ਹਨ।
ਇਹ ਸਮੱਸਿਆ ਜਿਆਦਾਤਰ ਉਦੋਂ ਵਾਪਰਦੀ ਹੈ ਜਦੋਂ ਆਈਟਮਾਂ ਇੱਕ ਐਰੇ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦੀਆਂ ਹਨ, ਜੋ ਅਕਸਰ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਡੇਟਾ ਢਾਂਚੇ ਵਿੱਚ ਹੁੰਦਾ ਹੈ। ਸਧਾਰਨ ਫੈਲਾਅ ਸੰਟੈਕਸ ਸਿਰਫ਼ ਆਬਜੈਕਟਾਂ ਲਈ ਪੁਆਇੰਟਰਾਂ ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ, ਨਾ ਕਿ ਐਰੇ ਦੀ ਅਸਲ ਡੂੰਘੀ ਕਾਪੀ, ਜਿਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਮੂਲ ਅਤੇ ਕਲੋਨ ਕੀਤੇ ਐਰੇ ਦੋਵਾਂ ਵਿੱਚ ਅਣਚਾਹੇ ਬਦਲਾਅ ਹੁੰਦੇ ਹਨ।
ਇਸ ਮੁੱਦੇ ਨੂੰ ਦਰਸਾਉਣ ਲਈ, ਅਸੀਂ ਇਸ ਲੇਖ ਵਿਚ ਇਕ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਉਦਾਹਰਣ ਦੇ ਕੇ ਜਾਵਾਂਗੇ. ਅਸੀਂ ਇੱਕ ਐਰੇ ਨੂੰ ਕਲੋਨ ਕਰਨ ਲਈ ਸਪ੍ਰੈਡ ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਜਿਸ ਵਿੱਚ ਟੀਮਾਂ ਦੇ ਨਾਮ ਸ਼ਾਮਲ ਹਨ। ਅੱਗੇ, ਅਸੀਂ ਕਾਪੀ ਕੀਤੇ ਐਰੇ ਵਿੱਚ ਬਦਲਾਅ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ ਅਤੇ ਦੇਖਾਂਗੇ ਕਿ ਕੀ ਅਸਲੀ ਐਰੇ ਵੀ ਬਦਲਿਆ ਗਿਆ ਹੈ।
ਇਸਦੇ ਪਿੱਛੇ ਦੀ ਵਿਧੀ ਨੂੰ ਸਮਝਣ ਅਤੇ ਸੰਭਾਵਿਤ ਉਪਚਾਰਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦੁਆਰਾ, ਅਸੀਂ JavaScript ਐਰੇ ਕਲੋਨਿੰਗ ਵਿਧੀਆਂ ਦੇ ਆਪਣੇ ਗਿਆਨ ਨੂੰ ਵਧਾਵਾਂਗੇ। ਵੱਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ, ਪਰਿਵਰਤਨਸ਼ੀਲ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਗਲਤੀਆਂ ਨੂੰ ਰੋਕਣ ਲਈ ਇਹ ਜ਼ਰੂਰੀ ਹੈ।
| ਹੁਕਮ | ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ |
|---|---|
| [...array] | ਸਪ੍ਰੈਡ ਓਪਰੇਟਰ, ਜੋ ਕਿ ਇਹ ਸੰਟੈਕਸ ਹੈ, ਨੂੰ ਇੱਕ ਐਰੇ ਦੀ ਇੱਕ ਘੱਟ ਕਾਪੀ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਦੀ ਵਰਤੋਂ ਇਸ ਲੇਖ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਮੂਲ ਐਰੇ ਨੂੰ ਕਲੋਨ ਕਰਨ ਲਈ ਕੀਤੀ ਗਈ ਸੀ, ਪਰ ਕਿਉਂਕਿ ਇਹ ਸਿਰਫ਼ ਇੱਕ ਘੱਟ ਨਕਲ ਬਣਾਉਂਦਾ ਹੈ, ਐਰੇ ਦੇ ਅੰਦਰ ਵਸਤੂਆਂ ਉਸੇ ਸੰਦਰਭ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੀਆਂ ਹਨ। |
| JSON.parse(JSON.stringify(array)) | ਇੱਕ ਐਰੇ ਦੀ ਡੂੰਘੀ ਕਲੋਨਿੰਗ ਇਸ ਸੁਮੇਲ ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਲਾਜ਼ਮੀ ਤੌਰ 'ਤੇ ਐਰੇ ਦੀ ਇੱਕ ਨਵੀਂ ਕਾਪੀ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਐਰੇ ਨੂੰ JSON ਸਤਰ ਵਿੱਚ ਬਦਲ ਕੇ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਵਸਤੂ ਵਿੱਚ ਵਾਪਸ ਪਾਰਸ ਕਰਕੇ ਅਸਲ ਨਾਲ ਆਬਜੈਕਟ ਹਵਾਲਿਆਂ ਨੂੰ ਸਾਂਝਾ ਨਹੀਂ ਕਰਦਾ ਹੈ। |
| _.cloneDeep(array) | ਇਹ ਲੋਡਸ਼ ਲਾਇਬ੍ਰੇਰੀ ਵਿਧੀ ਖਾਸ ਤੌਰ 'ਤੇ ਡੂੰਘੇ ਕਲੋਨਿੰਗ ਐਰੇ ਜਾਂ ਵਸਤੂਆਂ ਲਈ ਬਣਾਈ ਗਈ ਸੀ। ਗਾਰੰਟੀ ਦੇ ਕੇ ਕਿ ਨੇਸਟਡ ਵਸਤੂਆਂ ਦੀ ਨਕਲ ਵੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਸਾਂਝੇ ਸੰਦਰਭਾਂ ਤੋਂ ਬਚਿਆ ਜਾਂਦਾ ਹੈ। |
| for(n=0; n<a.length; n++) | ਲੂਪ ਲਈ ਇਹ ਕਲਾਸਿਕ ਇੱਕ ਐਰੇ ਉੱਤੇ ਚੱਲਣ ਲਈ n ਨਾਮਕ ਕਾਊਂਟਰ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਹਰੇਕ ਟੀਮ ਦਾ ਨਾਮ ਐਰੇ ਤੋਂ ਛਾਪਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ ਤਬਦੀਲੀ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਨਤੀਜਿਆਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ। |
| require('lodash') | ਇੱਕ Node.js ਵਾਤਾਵਰਣ ਵਿੱਚ, ਇਹ ਕਮਾਂਡ ਲੋਡਸ਼ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਆਯਾਤ ਕਰਦੀ ਹੈ। ਇਹ ਇਸਦੇ ਉਪਯੋਗਤਾ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪਹੁੰਚਯੋਗ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ _.cloneDeep ਸ਼ਾਮਲ ਹੈ, ਜੋ ਕਿ ਡੂੰਘੇ ਕਲੋਨਿੰਗ ਐਰੇ ਲਈ ਜ਼ਰੂਰੀ ਹੈ। |
| console.log() | ਇਹ ਫੰਕਸ਼ਨ ਕੰਸੋਲ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ, ਜਿਸਦੀ ਵਰਤੋਂ ਮੁੱਲ ਦਿਖਾਉਣ ਲਈ ਜਾਂ ਸਮੱਸਿਆ ਨਿਪਟਾਰਾ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਇਹ ਸ਼ੁਰੂਆਤੀ ਅਤੇ ਸੋਧੀਆਂ ਕਲੋਨ ਐਰੇ ਦੇ ਨਤੀਜਿਆਂ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਸੀ। |
| function change_team(d, club) | ਐਰੇ ਡੀ ਅਤੇ ਟੀਮ ਨਾਮ ਕਲੱਬ ਦੋ ਆਰਗੂਮੈਂਟਸ ਹਨ ਜੋ ਇਹ ਵਿਧੀ ਸਵੀਕਾਰ ਕਰਦੀ ਹੈ। ਉਸ ਤੋਂ ਬਾਅਦ, ਇਹ ਦੂਜੀ ਟੀਮ ਦੇ ਨਵੇਂ ਨਾਮ ਨਾਲ ਐਰੇ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਖੋਖਲੀ ਨਕਲ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ ਅਤੇ ਕਿਵੇਂ ਇੱਕ ਐਰੇ ਵਿੱਚ ਸੋਧ ਦੂਜੇ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਦੀ ਹੈ। |
| return | ਬਦਲੀ ਹੋਈ ਐਰੇ ਨੂੰ ਰਿਟਰਨ ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ change_team ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਇੱਕ ਪਰਿਵਰਤਨ ਦੇ ਬਾਅਦ ਸੰਸ਼ੋਧਿਤ ਬਣਤਰ ਨੂੰ ਵਾਪਸ ਕਰਨਾ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। |
JavaScript ਐਰੇ ਕਲੋਨਿੰਗ ਅਤੇ ਪਰਿਵਰਤਨ ਮੁੱਦਿਆਂ ਨੂੰ ਸਮਝਣਾ
ਇਹ JavaScript ਉਦਾਹਰਨ ਇਸ ਮੁੱਦੇ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਕਿਵੇਂ ਐਰੇ ਕਲੋਨਿੰਗ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਅਸਲ ਐਰੇ ਵਿੱਚ ਅਣਉਚਿਤ ਤਬਦੀਲੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਸਪ੍ਰੈਡ ਓਪਰੇਟਰ ਦੇ ਨਾਲ ਇੱਕ ਐਰੇ ਨੂੰ ਕਲੋਨ ਕਰਨ ਵੇਲੇ ਸ਼ੈਲੋ ਕਾਪੀਆਂ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਭਾਵੇਂ ਐਰੇ ਦੀ ਨਕਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਸਦੇ ਅੰਦਰ ਮੌਜੂਦ ਸਾਰੀਆਂ ਵਸਤੂਆਂ ਉਸੇ ਮੈਮੋਰੀ ਸਥਾਨਾਂ ਦਾ ਹਵਾਲਾ ਦਿੰਦੀਆਂ ਹਨ। ਟੀਮ ਦੇ ਨਾਵਾਂ ਦੇ ਸੰਬੰਧ ਵਿੱਚ, ਦੋਵੇਂ ਐਰੇ ਇੱਕੋ ਜਿਹੀਆਂ ਆਈਟਮਾਂ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹਨ ਭਾਵੇਂ ਐਰੇ ਬੀ ਐਰੇ ਦਾ ਇੱਕ ਕਲੋਨ ਹੈ a. ਸਿੱਟੇ ਵਜੋਂ, ਇੱਕ ਐਰੇ ਵਿੱਚ ਟੀਮ ਦੇ ਨਾਮ ਵਿੱਚ ਕੀਤੀ ਕੋਈ ਵੀ ਸੋਧ ਦੂਜੇ ਨੂੰ ਵੀ ਪ੍ਰਭਾਵਿਤ ਕਰੇਗੀ।
ਕਿਉਂਕਿ JavaScript ਮੁੱਲ ਦੀ ਬਜਾਏ ਸੰਦਰਭ ਦੁਆਰਾ ਚੀਜ਼ਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਇਹ ਵਿਵਹਾਰ ਵਾਪਰਦਾ ਹੈ। ਜਦੋਂ ਕਮਾਂਡ ਨਾਲ ਨਵਾਂ ਐਰੇ ਢਾਂਚਾ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਐਰੇ ਅੰਦਰਲੀਆਂ ਵਸਤੂਆਂ ਡੁਪਲੀਕੇਟ ਨਹੀਂ ਹੁੰਦੀਆਂ ਹਨ [...a]. ਇਸ ਤਰ੍ਹਾਂ, ਫੰਕਸ਼ਨ ਦੇ ਦੌਰਾਨ ਦੋਵੇਂ ਐਰੇ ਵਿੱਚ ਇੱਕੋ ਵਸਤੂ ਨੂੰ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਤਬਦੀਲੀ_ਟੀਮ ਟੀਮ ਦਾ ਨਾਂ ਬਦਲਣ ਲਈ ਕਿਹਾ ਗਿਆ ਹੈ। ਇਹ ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਉਂ, ਭਾਵੇਂ ਸਿਰਫ਼ ਇੱਕ ਐਰੇ ਨੂੰ ਬਦਲਿਆ ਜਾਣਾ ਸੀ, ਦੋਵੇਂ ਐਰੇ ਤਬਦੀਲੀ ਨੂੰ ਦਿਖਾਉਂਦੇ ਹਨ। ਆਬਜੈਕਟ ਦੇ JavaScript ਐਰੇ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਇੱਕ ਅਕਸਰ ਸਮੱਸਿਆ ਹੁੰਦੀ ਹੈ।
ਅਸੀਂ ਇਸ ਮੁੱਦੇ ਲਈ ਦੋ ਹੱਲ ਦਰਸਾਏ ਹਨ: ਡੂੰਘੀ ਕਲੋਨਿੰਗ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀ ਉਪਯੋਗਤਾ। ਦ JSON.parse(JSON.stringify(a)) ਫੰਕਸ਼ਨ ਐਰੇ ਨੂੰ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਅਤੇ ਇੱਕ ਡੂੰਘੀ ਕਾਪੀ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਦੁਬਾਰਾ ਵਾਪਸ ਆਉਂਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਵਰਤੋਂ ਵਿੱਚ ਆਸਾਨ ਹੈ ਅਤੇ ਆਈਟਮਾਂ ਦੇ ਇੱਕ ਨਵੇਂ ਸਮੂਹ ਨੂੰ ਤਿਆਰ ਕਰਨ ਲਈ ਕੁਸ਼ਲ ਹੈ ਜੋ ਅਸਲ ਐਰੇ ਨਾਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਾਲ ਸਬੰਧਤ ਨਹੀਂ ਹਨ। ਕਾਪੀ ਕੀਤੇ ਐਰੇ ਵਿੱਚ ਕੀਤੇ ਗਏ ਕਿਸੇ ਵੀ ਬਦਲਾਅ ਤੋਂ ਬਾਅਦ ਅਸਲੀ ਐਰੇ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਹੋਵੇਗਾ। ਹਾਲਾਂਕਿ, ਇਸ ਵਿਧੀ ਦੀਆਂ ਕਮੀਆਂ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਡੇਟਾ ਢਾਂਚੇ ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨਾਂ ਜਾਂ ਪਰਿਭਾਸ਼ਿਤ ਮੁੱਲਾਂ ਨਾਲ ਨਜਿੱਠਣਾ ਹੋਵੇ।
ਇੱਕ ਹੋਰ ਭਰੋਸੇਮੰਦ ਤਰੀਕਾ Lodash's ਦਾ ਫਾਇਦਾ ਕਰਦਾ ਹੈ _.ਕਲੋਨਦੀਪ ਤਕਨੀਕ. ਮਸ਼ਹੂਰ JavaScript ਉਪਯੋਗਤਾ ਲਾਇਬ੍ਰੇਰੀ Lodash ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਗਈਆਂ ਬਹੁਤ ਸਾਰੀਆਂ ਤਕਨੀਕਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਵਸਤੂਆਂ ਅਤੇ ਐਰੇ ਦੀ ਡੂੰਘੀ ਕਲੋਨਿੰਗ। ਇਹ ਤਕਨੀਕ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਨੇਸਟਡ ਵਸਤੂਆਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕਲੋਨ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਇਹ ਕੁਸ਼ਲ ਅਤੇ ਭਰੋਸੇਯੋਗ ਦੋਵੇਂ ਹਨ। ਇਹ JSON ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਨਾਲ ਜੁੜੀਆਂ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਦੇ ਹੋਏ, ਆਸਾਨੀ ਨਾਲ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਡੇਟਾ ਢਾਂਚੇ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ। ਇਹ ਦੋ ਡੂੰਘੇ-ਕਲੋਨਿੰਗ ਤਕਨੀਕਾਂ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਬਹੁਤ ਮਦਦਗਾਰ ਹੁੰਦੀਆਂ ਹਨ ਜਿੱਥੇ ਡੇਟਾ ਇਕਸਾਰਤਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦੀ ਹੈ ਕਿਉਂਕਿ ਉਹ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਅਣਕਿਆਸੇ ਮਾੜੇ ਪ੍ਰਭਾਵਾਂ ਤੋਂ ਬਚਦੀਆਂ ਹਨ ਜੋ ਐਰੇ ਜਾਂ ਆਬਜੈਕਟ ਹੇਰਾਫੇਰੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ।
JavaScript ਵਿੱਚ ਐਰੇ ਕਲੋਨਿੰਗ ਅਤੇ ਬਦਲਣਾ
ਇਹ ਉਦਾਹਰਨ ਇੱਕ JavaScript ਫਰੰਟ-ਐਂਡ ਹੱਲ ਦਿਖਾਉਂਦਾ ਹੈ ਜੋ ਐਰੇ ਸੰਪਾਦਨ ਅਤੇ ਕਲੋਨਿੰਗ ਵਿਧੀਆਂ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦਾ ਹੈ।
a = [];a[0] = {};a[0].team = "Arsenal";a[1] = {};a[1].team = "Chelsea";a[2] = {};a[2].team = "West Ham";function change_team(d, club) {d[1].team = club;return d;}b = [...a]; // Shallow copy of the arraychange_team(b, "Spurs");for(n = 0; n < a.length; n++) {console.log(n + "] " + a[n].team); // Arsenal, Chelsea, West Ham}for(n = 0; n < b.length; n++) {console.log(n + "] " + b[n].team); // Arsenal, Spurs, West Ham}
ਪਰਿਵਰਤਨ ਨੂੰ ਰੋਕਣ ਲਈ JavaScript ਵਿੱਚ ਡੂੰਘੀ ਕਲੋਨਿੰਗ ਐਰੇ
ਇਹ ਉਦਾਹਰਨ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਡੂੰਘੀ ਕਾਪੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੂਲ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕੀਤੇ ਬਿਨਾਂ ਕਲੋਨ ਕੀਤੇ ਐਰੇ ਵਿੱਚ ਬਦਲਾਅ ਕਿਵੇਂ ਕਰਨਾ ਹੈ।
a = [];a[0] = {};a[0].team = "Arsenal";a[1] = {};a[1].team = "Chelsea";a[2] = {};a[2].team = "West Ham";function deepCloneArray(arr) {return JSON.parse(JSON.stringify(arr)); // Deep copy}function change_team(d, club) {d[1].team = club;return d;}b = deepCloneArray(a);change_team(b, "Spurs");for(n = 0; n < a.length; n++) {console.log(n + "] " + a[n].team); // Arsenal, Chelsea, West Ham}for(n = 0; n < b.length; n++) {console.log(n + "] " + b[n].team); // Arsenal, Spurs, West Ham}
JavaScript ਵਿੱਚ ਐਰੇ ਕਲੋਨ ਕਰਨ ਲਈ ਲੋਡਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
ਹਵਾਲਾ-ਅਧਾਰਿਤ ਸੋਧਾਂ ਨੂੰ ਰੋਕਣ ਲਈ, ਇਹ ਉਦਾਹਰਨ ਲੋਡਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੂੰਘੇ ਕਲੋਨ ਐਰੇ, ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਉਪਯੋਗਤਾ ਪੈਕੇਜ ਹੈ।
const _ = require('lodash');a = [];a[0] = {};a[0].team = "Arsenal";a[1] = {};a[1].team = "Chelsea";a[2] = {};a[2].team = "West Ham";function change_team(d, club) {d[1].team = club;return d;}b = _.cloneDeep(a);change_team(b, "Spurs");for(n = 0; n < a.length; n++) {console.log(n + "] " + a[n].team); // Arsenal, Chelsea, West Ham}for(n = 0; n < b.length; n++) {console.log(n + "] " + b[n].team); // Arsenal, Spurs, West Ham}
ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਸੁਰੱਖਿਆ ਲਈ JavaScript ਵਿੱਚ ਐਰੇ ਕਲੋਨਿੰਗ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਾ
ਮੈਮੋਰੀ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਦੀ ਯੋਗਤਾ JavaScript ਐਰੇ ਕਲੋਨਿੰਗ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਵੱਡੇ ਪੱਧਰ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ। ਕਲੋਨਿੰਗ ਤਕਨੀਕਾਂ ਜੋ ਤੁਸੀਂ ਵੱਡੇ ਐਰੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਵਰਤਦੇ ਹੋ, ਮੈਮੋਰੀ ਉਪਯੋਗਤਾ ਅਤੇ ਗਤੀ 'ਤੇ ਮਹੱਤਵਪੂਰਣ ਪ੍ਰਭਾਵ ਪਾ ਸਕਦੇ ਹਨ। ਗੁੰਝਲਦਾਰ, ਨੇਸਟਡ ਢਾਂਚਿਆਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਖੋਖਲਾ ਨਕਲ ਕਰਨ ਦਾ ਤਰੀਕਾ, ਜੋ ਕਿ ਫੈਲਾਅ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ [...ਐਰੇ], ਇੰਨਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਨਹੀਂ ਹੈ ਅਤੇ ਛੋਟੀਆਂ ਐਰੇ ਲਈ ਹੌਲੀ ਹੈ। ਡੂੰਘੀ ਨਕਲ ਕਰਨ ਦੀਆਂ ਤਕਨੀਕਾਂ ਵਰਗੀਆਂ JSON.parse(JSON.stringify(ਐਰੇ)) ਜਾਂ ਲੋਡਾਸ਼ ਵਰਗੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ _.ਕਲੋਨਦੀਪ ਉੱਚ ਮੈਮੋਰੀ ਖਪਤ ਦੇ ਕਾਰਨ ਵੱਡੇ ਡੇਟਾ ਸੈੱਟਾਂ ਲਈ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਪਛੜ ਸਕਦਾ ਹੈ।
ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਹੋਰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇਹ ਮੁਲਾਂਕਣ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕਿਹੜੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਡੂੰਘੀਆਂ ਬਨਾਮ ਖੋਖਲੀਆਂ ਕਾਪੀਆਂ ਦੀ ਲੋੜ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਖੋਖਲੀ ਕਾਪੀ ਉਦੋਂ ਕਰੇਗੀ ਜੇਕਰ ਤੁਹਾਡੇ ਐਪਲੀਕੇਸ਼ਨ ਅੱਪਡੇਟ ਕੇਵਲ ਮੁੱਢਲੇ ਡੇਟਾ ਨੰਬਰਾਂ ਜਾਂ ਸਤਰਾਂ ਦੀਆਂ ਮੂਲ ਐਰੇ ਹਨ। ਹਾਲਾਂਕਿ, ਹਵਾਲਾ-ਅਧਾਰਿਤ ਮਾੜੇ ਪ੍ਰਭਾਵਾਂ ਨੂੰ ਰੋਕਣ ਲਈ, ਐਰੇ ਲਈ ਇੱਕ ਡੂੰਘੀ ਕਲੋਨ ਜ਼ਰੂਰੀ ਹੈ ਜਿਸ ਵਿੱਚ ਐਰੇ ਦੀਆਂ ਵਸਤੂਆਂ ਜਾਂ ਐਰੇ ਸ਼ਾਮਲ ਹਨ। ਡੂੰਘੀ ਕਲੋਨਿੰਗ ਤਕਨੀਕਾਂ ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਦੀ ਗਾਰੰਟੀ ਦਿੰਦੀਆਂ ਹਨ ਭਾਵੇਂ ਕਿ ਉਹ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਘਟਾ ਸਕਦੀਆਂ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਸਰਵਰ-ਸਾਈਡ ਤਰਕ ਜਾਂ ਰੀਐਕਟ ਸਟੇਟਸ ਵਰਗੇ ਰੀਅਲ-ਟਾਈਮ ਐਪਸ ਵਿੱਚ ਲੜੀਵਾਰ ਡੇਟਾ ਮਾਡਲਾਂ ਵਿੱਚ ਵੱਡੇ ਡੇਟਾਸੇਟਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ।
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸੁਰੱਖਿਆ ਲਈ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੀ ਕੁੰਜੀ ਅਣਜਾਣੇ ਵਿਚ ਪਰਿਵਰਤਨ ਤੋਂ ਬਚਣਾ ਹੈ। ਜਦੋਂ ਖੋਖਲੀਆਂ ਕਾਪੀਆਂ ਗਲਤ ਢੰਗ ਨਾਲ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਤਾਂ ਉਹ ਵਸਤੂ ਸੰਦਰਭਾਂ ਰਾਹੀਂ ਅਣਇੱਛਤ ਸੋਧਾਂ ਦੀ ਇਜਾਜ਼ਤ ਦੇ ਸਕਦੀਆਂ ਹਨ, ਜੋ ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਨੂੰ ਬੇਨਕਾਬ ਕਰ ਸਕਦੀਆਂ ਹਨ। ਡੂੰਘੀ ਨਕਲ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਕਲੋਨ ਕੀਤੀਆਂ ਐਰੇ ਜਾਂ ਵਸਤੂਆਂ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਅਸਲ ਡੇਟਾਸੈਟਾਂ ਵਿੱਚ ਲੀਕ ਨਹੀਂ ਹੁੰਦੀਆਂ, ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਦੀ ਰੱਖਿਆ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਵਿੱਤੀ ਜਾਂ ਮੈਡੀਕਲ ਸੌਫਟਵੇਅਰ ਵਰਗੇ ਸੰਵੇਦਨਸ਼ੀਲ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਗਲਤੀਆਂ ਨੂੰ ਟਾਲਦੀਆਂ ਹਨ। ਪ੍ਰਦਰਸ਼ਨ ਕਾਰਕਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ ਅਤੇ ਆਬਜੈਕਟ ਸੰਦਰਭਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਣਾ ਸਮਕਾਲੀ ਵੈੱਬ ਵਿਕਾਸ ਲਈ ਐਰੇ ਕਲੋਨਿੰਗ ਨੂੰ ਇੱਕ ਜ਼ਰੂਰੀ ਵਿਸ਼ਾ ਬਣਾਉਂਦਾ ਹੈ।
JavaScript ਐਰੇ ਕਲੋਨਿੰਗ ਬਾਰੇ ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ
- ਇੱਕ ਡੂੰਘੀ ਕਾਪੀ ਨੂੰ ਖੋਖਲੀ ਕਾਪੀ ਤੋਂ ਕੀ ਵੱਖਰਾ ਕਰਦਾ ਹੈ?
- ਇੱਕ ਖੋਖਲੀ ਕਾਪੀ, ਜਿਵੇਂ ਕਿ [...array], ਸਿਰਫ਼ ਇੱਕ ਐਰੇ ਦੇ ਉੱਚ-ਪੱਧਰੀ ਢਾਂਚੇ ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ; ਅਸਲੀ ਅਤੇ ਕਲੋਨ ਕੀਤੇ ਐਰੇ ਆਬਜੈਕਟ ਹਵਾਲੇ ਸਾਂਝੇ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦੇ ਹਨ। ਵਰਤ ਕੇ JSON.parse(JSON.stringify(array)) ਜਾਂ _.cloneDeep, ਇੱਕ ਡੂੰਘੀ ਕਾਪੀ ਹਰ ਪੱਧਰ ਦੀ ਨਕਲ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਨੇਸਟ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਵੀ ਸ਼ਾਮਲ ਹਨ।
- ਕਦੇ-ਕਦਾਈਂ ਕਲੋਨ ਕੀਤੇ ਗਏ ਐਰੇ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨਾ ਅਸਲ ਐਰੇ ਨੂੰ ਕਿਉਂ ਬਦਲ ਸਕਦਾ ਹੈ?
- ਇੱਕ ਐਰੇ ਵਿੱਚ ਆਬਜੈਕਟ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਇੱਕ ਖੋਖਲੀ ਕਾਪੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਲੋਨ ਕਰਦੇ ਹੋ, ਅਜੇ ਵੀ ਉਸੇ ਮੈਮੋਰੀ ਪਤਿਆਂ ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ ਜਿਵੇਂ ਕਿ ਅਸਲ ਐਰੇ। ਨਤੀਜੇ ਵਜੋਂ, ਕਲੋਨ ਕੀਤੇ ਐਰੇ ਦੇ ਆਬਜੈਕਟ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਬਦਲਣਾ ਵੀ ਮੂਲ ਨੂੰ ਸੋਧਦਾ ਹੈ।
- ਮੈਨੂੰ JavaScript ਵਿੱਚ ਡੂੰਘੀ ਕਾਪੀ ਦੀ ਵਰਤੋਂ ਕਦੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ?
- ਜਦੋਂ ਐਰੇ ਜਾਂ ਔਬਜੈਕਟਸ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ ਜਿਸ ਵਿੱਚ ਗੁੰਝਲਦਾਰ ਬਣਤਰ ਜਾਂ ਨੇਸਟਡ ਆਬਜੈਕਟ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਤੁਹਾਨੂੰ ਹਵਾਲਾ-ਅਧਾਰਿਤ ਸੋਧਾਂ ਨੂੰ ਰੋਕਣ ਲਈ ਡੂੰਘੀ ਕਾਪੀ ਕਰਨ ਦੇ ਢੰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।
- ਲੋਡਸ਼ JavaScript ਵਿੱਚ ਐਰੇ ਕਲੋਨਿੰਗ ਵਿੱਚ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ?
- ਦ _.cloneDeep ਵਿਧੀ, ਲੋਡਸ਼ ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤੀ ਗਈ, ਡੂੰਘੀ ਕਲੋਨਿੰਗ ਐਰੇ ਅਤੇ ਆਬਜੈਕਟ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ, ਇਸ ਗੱਲ ਦੀ ਗਾਰੰਟੀ ਦਿੰਦੀ ਹੈ ਕਿ ਕਾਪੀਆਂ ਅਸਲੀ ਡੇਟਾ ਦੇ ਕਿਸੇ ਵੀ ਹਵਾਲੇ ਨੂੰ ਸਾਂਝਾ ਨਹੀਂ ਕਰਦੀਆਂ ਹਨ।
- ਜਦੋਂ ਡੂੰਘੇ ਕਲੋਨਿੰਗ ਐਰੇ ਹੁੰਦੇ ਹਨ ਤਾਂ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਕੀ ਵਿਚਾਰ ਹੁੰਦੇ ਹਨ?
- ਡੂੰਘੀ ਕਲੋਨਿੰਗ ਮੈਮੋਰੀ-ਇੰਟੈਂਸਿਵ ਅਤੇ ਹੌਲੀ ਹੋ ਸਕਦੀ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਵੱਡੇ ਡੇਟਾਸੇਟਾਂ ਜਾਂ ਗੁੰਝਲਦਾਰ ਨੇਸਟਡ ਢਾਂਚੇ ਨਾਲ ਨਜਿੱਠਦੇ ਹੋਏ। ਡੂੰਘੀਆਂ ਕਾਪੀਆਂ ਸਿਰਫ਼ ਉਦੋਂ ਹੀ ਵਰਤੀਆਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ ਜਦੋਂ ਬਿਲਕੁਲ ਜ਼ਰੂਰੀ ਹੋਵੇ; ਨਹੀਂ ਤਾਂ, ਤੁਹਾਨੂੰ ਆਪਣੀ ਅਰਜ਼ੀ ਦੀਆਂ ਖਾਸ ਲੋੜਾਂ ਦੇ ਮੱਦੇਨਜ਼ਰ ਹੋਰ ਵਿਕਲਪਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
JavaScript ਵਿੱਚ ਐਰੇ ਕਲੋਨਿੰਗ ਬਾਰੇ ਅੰਤਿਮ ਵਿਚਾਰ
JavaScript ਐਰੇ ਕਲੋਨਿੰਗ ਨੂੰ ਖੋਖਲੇ ਅਤੇ ਡੂੰਘੇ ਨਕਲ ਦੀ ਇੱਕ ਠੋਸ ਸਮਝ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਹਾਲਾਂਕਿ ਸਪ੍ਰੈਡ ਓਪਰੇਟਰ ਨਾਲ ਘੱਟ ਕਾਪੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ, ਇਕੱਲੇ ਐਰੇ ਦੇ ਅੰਦਰ ਵਸਤੂਆਂ ਦੇ ਹਵਾਲੇ ਦੀ ਨਕਲ ਕਰਨ ਨਾਲ ਅਣਚਾਹੇ ਸੋਧਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ।
ਸਥਿਤੀਆਂ ਵਿੱਚ ਆਦਰਸ਼ ਹੱਲ ਜਿੱਥੇ ਅਸਲ ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਣਾ ਜ਼ਰੂਰੀ ਹੈ, ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੂੰਘੀ ਨਕਲ ਕਰਨਾ JSON ਪਾਰਸਿੰਗ ਜਾਂ ਉਪਯੋਗਤਾ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਰਗੀਆਂ ਲੋਦਾਸ਼. ਗੁੰਝਲਦਾਰ ਡੇਟਾ ਢਾਂਚੇ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ ਦੋਵੇਂ ਪਹੁੰਚ ਜ਼ਰੂਰੀ ਹਨ ਕਿਉਂਕਿ ਉਹ ਗਾਰੰਟੀ ਦਿੰਦੇ ਹਨ ਕਿ ਕਾਪੀ ਕੀਤੇ ਗਏ ਐਰੇ ਵਿੱਚ ਕੀਤੀਆਂ ਤਬਦੀਲੀਆਂ ਅਸਲ ਇੱਕ ਨੂੰ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰਨਗੇ।
ਹਵਾਲੇ ਅਤੇ ਹੋਰ ਪੜ੍ਹਨਾ
- JavaScript ਵਿੱਚ ਡੂੰਘੇ ਕਲੋਨਿੰਗ ਆਬਜੈਕਟਾਂ 'ਤੇ ਇਹ ਲੇਖ ਨੇਸਟਡ ਡੇਟਾ ਢਾਂਚੇ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਸੰਕਲਪ ਅਤੇ ਵੱਖ-ਵੱਖ ਪਹੁੰਚਾਂ ਦੀ ਵਿਆਖਿਆ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਥੇ ਵਿਸ਼ੇ ਬਾਰੇ ਹੋਰ ਜਾਣ ਸਕਦੇ ਹੋ: MDN ਵੈੱਬ ਡੌਕਸ - Object.assign() .
- ਲੋਡਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਲੋਨਿੰਗ ਐਰੇ ਅਤੇ ਵਸਤੂਆਂ ਦੀ ਡੂੰਘੀ ਸਮਝ ਲਈ, ਇਹ ਸਰੋਤ ਜ਼ਰੂਰੀ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ _.ਕਲੋਨਦੀਪ: ਲੋਡਸ਼ ਦਸਤਾਵੇਜ਼ .
- JSON ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ JavaScript ਕਲੋਨਿੰਗ ਤਕਨੀਕਾਂ ਲਈ ਇੱਕ ਹੋਰ ਵਧੀਆ ਗਾਈਡ ਸਟੈਕਓਵਰਫਲੋ 'ਤੇ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ: ਸਟੈਕ ਓਵਰਫਲੋ - JavaScript ਵਿੱਚ ਕੁਸ਼ਲ ਕਲੋਨਿੰਗ .