JavaScript માં Shallow Copy વિરુદ્ધ Deep Copy

JavaScript ડેટા પ્રકાર (data type) ના આધારે કોપી કરવાની બે રીતે સંભાળે છે.

Primitive Values (Copy by Value)

પ્રિમીટિવ પ્રકારોમાં strings, numbers, booleans, symbols, bigInt, અને null નો સમાવેશ થાય છે. જ્યારે તમે પ્રિમીટિવની કોપી કરો છો, ત્યારે JavaScript મેમરીમાં એક નવું સ્વતંત્ર વર્ઝન બનાવે છે.

Example:

let a = 10;
let b = a;
b = 20;

પરિણામ: a ની કિંમત 10 જ રહે છે.

Non-Primitive Values (Copy by Reference)

Objects અને arrays અલગ રીતે કામ કરે છે. તેઓ references નો ઉપયોગ કરે છે. જ્યારે તમે કોઈ object ની કોપી કરો છો, ત્યારે તમે ફક્ત મેમરીમાં તેના લોકેશનના પોઇન્ટરની જ કોપી કરો છો.

Example:

let original = { name: "YOO" };
let copy = original;
copy.name = "NEW";

પરિણામ: original.name હવે "NEW" છે.

તફાવત: Shallow વિરુદ્ધ Deep

Shallow copy એ object ના ઉપરના સ્તર (top level) ની કોપી કરે છે. જો object માં nested objects હોય, તો તે હજુ પણ મૂળ nested references તરફ જ નિર્દેશ કરે છે. Deep copy તમામ નવી કિંમતો સાથે એક સંપૂર્ણપણે નવું object બનાવે છે.

તેને પિઝાના ઉદાહરણથી સમજો:

• Shallow Copy: તમે અને તમારા મિત્ર એક જ પિઝા વહેંચો છો. જો તમારો મિત્ર એક સ્લાઈસ ખાય છે, તો તમારા માટે પણ પિઝા નાનો થઈ જાય છે.
• Deep Copy: તમારા બંને પાસે તમારા પોતાના અલગ પિઝા છે. જો તમારો મિત્ર એક સ્લાઈસ ખાય છે, તો તમારો પિઝા એમનેમ જ રહેશે.

Shallow Copy પદ્ધતિ

તમે shallow copy બનાવવા માટે spread operator (...) નો ઉપયોગ કરી શકો છો.

let original = { name: "YOO", details: { age: 22 } };
let copy = { ...original };

ચેતવણી: જો તમે original.details.age બદલો છો, તો copy.details.age પણ બદલાઈ જાય છે. આ shallow copy નો trap છે.

Deep Copy પદ્ધતિઓ

1. structuredClone()

આ આધુનિક બ્રાઉઝર્સ અને Node.js માં એક built-in ફંક્શન છે. તે nested structures ને સંપૂર્ણ રીતે સંભાળે છે.

ફાયદા:

• ઝડપી અને નેટિવ (native).
• Dates, RegExp, અને Maps ને સંભાળે છે.

ગેરફાયદા:

• જો object માં functions અથવા DOM nodes હોય તો તે નિષ્ફળ જાય છે.

2. JSON.parse(JSON.stringify())

આ એક જૂની યુક્તિ છે જેમાં તમે object ને string માં અને ફરીથી object માં રૂપાંતરિત કરો છો.

તેને કેમ ટાળવું જોઈએ:

• તે undefined, Map, Set, અથવા Infinity જેવો ડેટા ગુમાવે છે.
• તે અમુક કિંમતોને બગાડી (corrupt) શકે છે.

Source: https://dev.to/yogesh_992/shallow-copy-vs-deep-copy-in-java-script-explained-in-easiest-way-3dg5