ઉકેલાયેલ: સંદર્ભ વિના ક્લોન એરે

મુખ્ય પૃષ્ઠ » જાવાસ્ક્રિપ્ટ » કોણીય » ઉકેલાયેલ: સંદર્ભ વિના ક્લોન એરે

પ્રોગ્રામિંગની દુનિયામાં, ખાસ કરીને JavaScript સાથે કામ કરતી વખતે, ત્યાં સામાન્ય કાર્યો અને ક્રિયાઓ છે જેનો વિકાસકર્તાને વારંવાર સામનો કરવો પડે છે. આવા એક પુનરાવર્તિત કાર્યમાં એરે સાથે કામ કરવાનો સમાવેશ થાય છે. JavaScript કોડિંગમાં એરે અનિવાર્ય છે. તેમ છતાં, એક સમસ્યા વિકાસકર્તાઓને વારંવાર આવે છે તે મૂળ એરેના કોઈપણ સંદર્ભ વિના એરેને ક્લોન અથવા કૉપિ કરવાની જરૂર છે. આ નિર્ણાયક છે જ્યારે અમે મૂળ પર કોઈ અસર કર્યા વિના એરે નકલમાં ફેરફાર કરવા માંગીએ છીએ. હવે, ચાલો આ હાંસલ કરવામાં મદદ કરતી બહુવિધ પદ્ધતિઓનો અભ્યાસ કરીએ.

JavaScript માં સંદર્ભ વિના એરેને ક્લોન કરવાની પદ્ધતિઓ

એરેને ક્લોન કરવા માટેની એક સામાન્ય પ્રથા છે સ્લાઇસ() or કોન્કેટ() પદ્ધતિઓ આ પદ્ધતિઓ સમાન તત્વો સાથે નવી એરે પેદા કરે છે. જો કે, ત્યાં એક નુકસાન છે; તેઓ માત્ર એક હાથ ધરે છે છીછરી નકલ, જેનો અર્થ છે નેસ્ટેડ એરે અથવા ઑબ્જેક્ટ્સ સંદર્ભ દ્વારા નકલ કરવામાં આવશે - મૂલ્ય નહીં. ડીપ કોપી કરવાની અન્ય રીતો, અથવા સંદર્ભ વિના એરેને ક્લોન કરવાનો સમાવેશ થાય છે JSON પદ્ધતિઓ, વિનાશ, અને પુસ્તકાલયો જેમ કે લોદશ.

const originalArray = [1, 2, ['a', 'b'], {a:1, b:2}];
const clonedArray = [...originalArray];

કોડનું પગલું દ્વારા પગલું સમજૂતી

અહીં ઉપર દર્શાવેલ JavaScript કોડનું પગલું-દર-પગલાં ભંગાણ છે.

• પ્રથમ લીટી મૂળ એરેને પ્રારંભ કરે છે. મૂળ એરેમાં સંખ્યાઓ, નેસ્ટેડ એરે અને ઑબ્જેક્ટ સહિત વિવિધ ઘટકોનો સમાવેશ થાય છે.
• બીજી લાઇન મૂળ એરેને ક્લોન કરવા માટે નવા ES6 સ્પ્રેડ સિન્ટેક્સનો ઉપયોગ કરે છે. જો કે, તે માત્ર છીછરી નકલ કરે છે. અર્થ, નેસ્ટેડ એરે અને એરેની અંદરનો ઑબ્જેક્ટ હજુ પણ સમાન મેમરી સ્પેસ તરફ નિર્દેશ કરે છે. તેથી, આ ઘટકોમાં કરવામાં આવેલ કોઈપણ ફેરફારો મૂળ એરેમાં પ્રતિબિંબિત થશે.

એરેના ઊંડા ક્લોનિંગ માટે, JSON પદ્ધતિઓ અને લોડાશ લાઇબ્રેરીનો ઉપયોગ કરી શકાય છે.

ક્લોનિંગ માટે JSON પદ્ધતિઓનો ઉપયોગ

`JSON.parse()` અને `JSON.stringify()` પદ્ધતિઓ દરેક વખતે એરેની નવી સ્વતંત્ર નકલની ખાતરી કરે છે. જો કે, એરેની અંદરના કાર્યો અને તારીખોની વાત આવે ત્યારે તેની મર્યાદાઓ હોય છે.

const originalArray = [1, 2, ['a', 'b'], {a:1, b:2}];
const clonedArray = JSON.parse(JSON.stringify(originalArray));

ડીપ ક્લોનિંગ એરે માટે લોડાશનો ઉપયોગ

નેસ્ટેડ સ્ટ્રક્ચર્સ સાથે જટિલ એરેને હેન્ડલ કરતી વખતે, ભરોસાપાત્ર લાઇબ્રેરી દ્વારા પૂરી પાડવામાં આવેલ સારી-ઑપ્ટિમાઇઝ પદ્ધતિનો ઉપયોગ કરીને ઘણી મુશ્કેલી બચાવી શકાય છે. આ તે છે જ્યાં લોડાશ તેની `_.cloneDeep()` પદ્ધતિ સાથે રમતમાં આવે છે.

const originalArray = [1, 2, ['a', 'b'], {a:1, b:2}];
const clonedArray = _.cloneDeep(originalArray);

JavaScript એરેની વર્સેટિલિટી અને જટિલતાને જોતાં, અણધારી આડ-અસર અને ભૂલોને ટાળવા માટે તેમને કેવી રીતે ક્લોન અથવા કૉપિ કરવી તે સમજવું મહત્વપૂર્ણ છે. તમારી અરજી માટે કયા પ્રકારનું ક્લોનિંગ (છીછરું અથવા ઊંડા) જરૂરી છે તે હંમેશા ધ્યાનમાં રાખવું એ સારી પ્રથા છે. દરમિયાન, JavaScript લાઇબ્રેરીઓ, જેમ કે Lodash, જટિલ ક્લોનિંગ કાર્યોને હેન્ડલ કરવા માટે અસરકારક સાધનો બની શકે છે, ત્યાંથી તમારી JavaScript મુસાફરીને સરળ બનાવે છે.