¿Cómo copiar o ampliar un array?

സോഫ്റ്റ്‌വെയർ വികസനത്തിൽ, arrays അല്ലെങ്കിൽ അറേകൾ പ്രോഗ്രാമിംഗിന്റെ ഒരു പ്രധാന ഭാഗത്തെ പ്രതിനിധീകരിക്കുന്നു. അവ ഒരേ പേരിൽ വിവരങ്ങളുടെ ഒരു കൂട്ടം സംഭരിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്ന ഡാറ്റാ ഘടനകളാണ്, കൃത്രിമത്വവും ഡാറ്റയിലേക്കുള്ള പ്രവേശനവും സുഗമമാക്കുന്നു. ഡാറ്റയുടെ വലുപ്പവും തരവും എന്തുതന്നെയായാലും, പ്രോഗ്രാമർമാർക്ക് ആവശ്യമുള്ള സമയങ്ങളുണ്ട് ഒരു അറേ പകർത്തുക അല്ലെങ്കിൽ വികസിപ്പിക്കുക. തുടർന്നുള്ള ലേഖനത്തിൽ, വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ഈ പ്രവർത്തനങ്ങൾ എങ്ങനെ നടത്താമെന്ന് വിശദമായി വിശദീകരിക്കുന്നതിൽ ഞങ്ങൾ ശ്രദ്ധ കേന്ദ്രീകരിക്കും.

ഒരു അറേ പകർത്തുകയോ വികസിപ്പിക്കുകയോ ചെയ്യേണ്ടതിന്റെ ആവശ്യകത മനസ്സിലാക്കുന്നു

പ്രോഗ്രാമിംഗിൽ, നമുക്ക് ആവശ്യമുള്ള സാഹചര്യങ്ങളിൽ നമ്മൾ പലപ്പോഴും സ്വയം കണ്ടെത്തുന്നു ഒരു അറേ പകർത്തുക അല്ലെങ്കിൽ വികസിപ്പിക്കുക. ഉദാഹരണത്തിന്, നമുക്ക് ഒരു പകർപ്പ് സംരക്ഷിക്കേണ്ടതായി വന്നേക്കാം ഒരു ശ്രേണിയുടെ യഥാർത്ഥ ശ്രേണിയിൽ മാറ്റം വരുത്താതെ പ്രവർത്തനങ്ങൾ നടത്താൻ. അല്ലെങ്കിൽ ഒരുപക്ഷേ, ഞങ്ങളുടെ അറേ നിറഞ്ഞു, കൂടുതൽ ഘടകങ്ങൾ ചേർക്കുന്നതിന് അതിൻ്റെ വലുപ്പം വർദ്ധിപ്പിക്കേണ്ടതുണ്ട്. ഈ സന്ദർഭങ്ങളിൽ, ഒരു അറേ പകർത്തുന്നതിനോ വികസിപ്പിക്കുന്നതിനോ ഉള്ള പ്രവർത്തനം അത്യാവശ്യമാണ്. ഈ ഫംഗ്‌ഷൻ അറേയുടെ വലുപ്പം പകർത്തുന്നതിനോ വർദ്ധിപ്പിക്കുന്നതിനോ മാത്രമല്ല, ആവശ്യമായ ഡാറ്റ മാത്രം സംഭരിച്ചുകൊണ്ട് മെമ്മറി ഉപയോഗം കുറയ്ക്കുന്നതിനും ഇത് സഹായിക്കുന്നു.

മറുവശത്ത്, അത് വിലമതിക്കുന്നു അത് സൂചിപ്പിക്കുക ജാവയിലെ അറേകൾ മാറ്റമില്ലാത്ത വസ്തുക്കളാണ്, അതായത്, ഒരു അറേ സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, അതിൻ്റെ വലുപ്പം മാറ്റാൻ കഴിയില്ല. ജാവയിൽ ഒരു അറേ "വികസിപ്പിക്കാൻ", ഞങ്ങൾ ഒരു പുതിയ വലിയ അറേ സൃഷ്ടിക്കേണ്ടതുണ്ട്, തുടർന്ന് യഥാർത്ഥ അറേയുടെ ഘടകങ്ങൾ പുതിയതിലേക്ക് പകർത്തേണ്ടതുണ്ട്. ഇത് അൽപ്പം മടുപ്പിക്കുന്നതാണ്, പക്ഷേ ജാവ സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ നിർമ്മിച്ച രീതികളുണ്ട് System.arraycopy() y Arrays.copyOf() അത് സുഗമമാക്കാൻ കഴിയും ഈ പ്രക്രിയ. ജാവാസ്ക്രിപ്റ്റ് അല്ലെങ്കിൽ പൈത്തൺ പോലെയുള്ള ഡൈനാമിക് ഡാറ്റാ ഘടനകൾ കൈകാര്യം ചെയ്യുന്ന ഭാഷകൾക്ക്, പ്രക്രിയ വളരെ ലളിതമാണ് കൂടാതെ ഇതുപോലുള്ള രീതികളുണ്ട് push() y append() പുതിയ ഒരെണ്ണം സൃഷ്‌ടിക്കാതെ തന്നെ നിലവിലുള്ള അറേയിലേക്ക് ഘടകങ്ങൾ ചേർക്കാൻ അനുവദിക്കുന്നവ.

ജാവാസ്ക്രിപ്റ്റിൽ അറേകൾ പകർത്തുന്നതിനുള്ള രീതികൾ പരിശോധിക്കുന്നു

ജാവാസ്ക്രിപ്റ്റിൽ ഒരു അറേ പകർത്താനോ തനിപ്പകർപ്പാക്കാനോ ഉള്ള ഏറ്റവും സാധാരണമായ മാർഗ്ഗം ഉപയോഗിക്കുക എന്നതാണ് സ്ലൈസ് () രീതി. ഈ രീതി ആരംഭ, അവസാന സൂചികകൾക്കിടയിൽ സൃഷ്‌ടിച്ച ഒരു ഉപവിഭാഗത്തിൽ നിന്നുള്ള അറേയുടെ ആഴം കുറഞ്ഞ പകർപ്പ് നൽകുന്നു. ഇത് ഒറിജിനൽ അറേയെ പരിഷ്‌ക്കരിക്കില്ല, കൂടാതെ പകർത്തിയ അറേയെ യഥാർത്ഥ അറേയിൽ നിന്ന് പൂർണ്ണമായും വേർതിരിക്കുന്നു. ഒരു അറേയ്ക്കുള്ളിൽ ഒബ്‌ജക്റ്റുകൾ പകർത്തുമ്പോൾ, പുതിയ സംഭവങ്ങൾ സൃഷ്ടിക്കുന്നതിനുപകരം യഥാർത്ഥ ഒബ്‌ജക്റ്റുകളിലേക്ക് റഫറൻസുകൾ സൃഷ്ടിക്കപ്പെടുന്നു എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഇതിനർത്ഥം നിങ്ങൾ പകർത്തിയ അറേയിലെ ഒബ്‌ജക്‌റ്റിൽ മാറ്റം വരുത്തുകയാണെങ്കിൽ, അത് യഥാർത്ഥ അറേയിലും പരിഷ്‌കരിക്കപ്പെടും. ചിത്രീകരിക്കാൻ ചില കോഡുകൾ ഇതാ:


let arrayOriginal = ['a', 'b', 'c', 'd', 'e'];
let arrayCopia = arrayOriginal.slice();


Si lo que necesitas es ഒരു അറേ വികസിപ്പിക്കുക, JavaScript അത് നമുക്ക് വാഗ്ദാനം ചെയ്യുന്നു അത് ചെയ്യാൻ നിരവധി വഴികൾ. സ്‌പ്രെഡ് ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നതാണ് ഒരു രീതി. അറേയ്‌ക്കുള്ളിൽ ഇറ്ററബിൾ എലമെൻ്റുകൾ വികസിപ്പിക്കാൻ ഈ ഓപ്പറേറ്റർ നിങ്ങളെ അനുവദിക്കുന്നു സൃഷ്ടിക്കാൻ യഥാർത്ഥ അറേയുടെ ഘടകങ്ങളും അധിക ഘടകങ്ങളും അടങ്ങുന്ന ഒരു പുതിയ അറേ. ഒന്നോ അതിലധികമോ അറേകളോ മൂല്യങ്ങളോ ഉപയോഗിച്ച് യഥാർത്ഥ അറേയിൽ ചേരുന്നതിൻ്റെ ഫലമായ ഒരു പുതിയ അറേ തിരികെ നൽകുന്ന കോൺകാറ്റ്() രീതിയാണ് മറ്റൊരു രീതി. അവസാനമായി, ഒരു അറേയുടെ അവസാനത്തിൽ ഒന്നോ അതിലധികമോ ഘടകങ്ങൾ ചേർക്കുകയും അറേയുടെ പുതിയ ദൈർഘ്യം നൽകുകയും ചെയ്യുന്ന പുഷ്() രീതിയും നിങ്ങൾക്ക് ഉപയോഗിക്കാം. ഇവിടെ നിങ്ങൾക്ക് ഉണ്ട് ചില ഉദാഹരണങ്ങൾ:


let array1 = [1, 2, 3];
let array2 = [...array1, 4, 5, 6]; // array2 ahora es [1, 2, 3, 4, 5, 6]



let array3 = [1, 2, 3];
let array4 = array3.concat([4, 5, 6]); // array4 ahora es [1, 2, 3, 4, 5, 6]



let array5 = [1, 2, 3];
array5.push(4, 5, 6); // array5 ahora es [1, 2, 3, 4, 5, 6]


ഒരു അറേ വികസിപ്പിക്കുന്നു: ശുപാർശ ചെയ്യുന്ന സാങ്കേതിക വിദ്യകളും മറ്റ് ഓപ്ഷനുകളും

പ്രോഗ്രാമിംഗിൽ ഒരു അറേ വികസിപ്പിക്കുന്നത് ഒരു സാധാരണ ജോലിയാണ്, പ്രത്യേകിച്ചും വലിയ അളവിലുള്ള ഡാറ്റ സംഭരിക്കുന്നതിനും കൈകാര്യം ചെയ്യുന്നതിനും. എന്നിരുന്നാലും, ശരിയായ സാങ്കേതിക വിദ്യകൾ അറിയില്ലെങ്കിൽ ചുമതല വെല്ലുവിളി നിറഞ്ഞതായിരിക്കും. ഇവിടെ, ഒരു അറേ വികസിപ്പിക്കുന്നതിനുള്ള ചില ശുപാർശ വിദ്യകളും മറ്റ് ഓപ്ഷനുകളും ഞങ്ങൾ ചർച്ച ചെയ്യും. ഒന്നാമതായി, നിങ്ങൾക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കാം Array.prototype.concat(). ഈ ഫംഗ്ഷൻ രണ്ടോ അതിലധികമോ അറേകൾ സംയോജിപ്പിക്കുന്നു ഒറ്റയടിക്ക് മാട്രിക്സ്. കൂടാതെ, ഇത് യഥാർത്ഥ മെട്രിക്സുകളിൽ മാറ്റം വരുത്തുന്നില്ല, അതായത് ഡാറ്റ സമഗ്രത സംരക്ഷിക്കപ്പെടുന്നു. Array.prototype.concat() എങ്ങനെ ഉപയോഗിക്കാമെന്നതിൻ്റെ ഒരു ഉദാഹരണം ഇതാ:

let array1 = [1, 2, 3];
let array2 = [4, 5, 6];
let newArray = array1.concat(array2);

// newArray ahora es [1, 2, 3, 4, 5, 6]

മറ്റൊരു ഓപ്ഷൻ ഓപ്പറേറ്റർ ടെക്നിക് ഉപയോഗിക്കുക എന്നതാണ് വ്യാപനം (…) . ഒരു അറേയിൽ നിന്ന് ഘടകങ്ങൾ എടുത്ത് അവയെ ഒരു പുതിയ അറേയിൽ സ്ഥാപിക്കാൻ ഈ ഓപ്പറേറ്റർ നിങ്ങളെ അനുവദിക്കുന്നു. Array.prototype.concat() പോലെയല്ല, സ്‌പ്രെഡ് ഓപ്പറേറ്റർ അറേകളിലും ഒബ്‌ജക്റ്റുകളിലും നന്നായി പ്രവർത്തിക്കുന്നു. ഒരു അറേ പകർത്താനും ഇത് ഉപയോഗിക്കാം. സ്പ്രെഡ് ഓപ്പറേറ്റർ എങ്ങനെ ഉപയോഗിക്കാമെന്നതിന്റെ ഒരു ഉദാഹരണം ഇതാ:

let array1 = [1, 2, 3];
let newArray = [...array1, 4, 5, 6];

// newArray ahora es [1, 2, 3, 4, 5, 6]

അവസാനം, ഏത് രീതിയാണ് ഉപയോഗിക്കേണ്ടതെന്ന് തിരഞ്ഞെടുക്കുന്നത് നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ പ്രത്യേക ആവശ്യങ്ങളെ ആശ്രയിച്ചിരിക്കും. എന്നിരുന്നാലും, Array.prototype.concat() ഉം സ്‌പ്രെഡ് ഓപ്പറേറ്ററും അറേകൾ വികസിപ്പിക്കുന്നതിനുള്ള ഫലപ്രദമായ സാങ്കേതികതകളാണ്.

കാര്യക്ഷമമായ അറേ മാനേജ്മെന്റ്: കോഡ് പ്രകടനത്തിനുള്ള പ്രത്യാഘാതങ്ങൾ

അറേകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, എ ഓഹരികളുടെ ഇവയുടെ പകർപ്പ് അല്ലെങ്കിൽ വിപുലീകരണമാണ് ഏറ്റവും സാധാരണമായത്. എന്നിരുന്നാലും, ഈ പ്രവർത്തനങ്ങൾ എങ്ങനെ ചെയ്യണമെന്ന് അറിയേണ്ടത് അത്യാവശ്യമാണ് ഫലപ്രദമായി നല്ല കോഡ് പ്രകടനം ഉറപ്പാക്കാൻ. അതിനാൽ, ഞങ്ങൾ രണ്ട് പ്രധാന രീതികൾ വിശകലനം ചെയ്യാൻ പോകുന്നു: Array.prototype.slice() y Array.prototype.concat().

നമുക്ക് ഒരു അറേ പകർത്തേണ്ടിവരുമ്പോൾ, നമുക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കാം slice(). അറേയുടെ ഒരു ഭാഗത്തിന്റെ ആഴം കുറഞ്ഞ പകർപ്പ് ഒരു പുതിയ അറേ ഒബ്‌ജക്റ്റിലേക്ക് സൃഷ്‌ടിക്കാൻ ഈ രീതി ഞങ്ങളെ അനുവദിക്കുന്നു. ഞങ്ങളുടെ അറേയുടെ പൂർണ്ണമായ ഡ്യൂപ്ലിക്കേറ്റ് നിർമ്മിക്കുന്നതിന്, ഇതുപോലുള്ള വാദങ്ങളൊന്നുമില്ലാതെ ഞങ്ങൾ സ്ലൈസ് ഉപയോഗിക്കുന്നു:

യഥാർത്ഥ var = [1, 2, 3, 4, 5]; var കോപ്പി = original.slice();

ഇത് 'ഒറിജിനൽ' അറേയുടെ അതേ മൂല്യങ്ങളുള്ള ഒരു പുതിയ 'പകർപ്പ്' അറേ നൽകും. എന്നിരുന്നാലും, ഈ രീതി വലിയ അറേകൾക്ക് ഏറ്റവും കാര്യക്ഷമമല്ലെന്ന് പരിഗണിക്കേണ്ടതാണ്, കാരണം ഇത് അമിതമായ മെമ്മറി ഉപയോഗത്തിനും കോഡ് മാന്ദ്യത്തിനും കാരണമാകും.

അറേകൾ വികസിപ്പിക്കുന്നത് സംബന്ധിച്ച്, ഫംഗ്ഷൻ ഉപയോഗിക്കാൻ ഞങ്ങൾ നിർദ്ദേശിക്കുന്നു concat(). രണ്ടോ അതിലധികമോ അറേകൾ ലയിപ്പിക്കുന്നതിനും ഒരു പുതിയ അറേ നൽകുന്നതിനും ഈ രീതി ഉപയോഗിക്കുന്നു. നമുക്ക് ചേരാൻ ആഗ്രഹിക്കുന്ന 'array1', 'array2' എന്നീ രണ്ട് അറേകൾ ഉണ്ടെന്ന് സങ്കൽപ്പിക്കുക. അതിനാൽ, നമുക്ക് കോൺകാറ്റ് ഇനിപ്പറയുന്ന രീതിയിൽ ഉപയോഗിക്കാം:

var array1 = [1, 2, 3]; var array2 = [4, 5, 6]; var വിപുലമായ = array1.concat(array2);

ഇത് [1, 2, 3, 4, 5, 6] മൂല്യങ്ങളുള്ള ഒരു 'വിപുലീകരിച്ച' അറേ നൽകും. അത് ഓർക്കുന്നത് ഉറപ്പാക്കുക, അതേസമയം concat ചെറിയ അറേകൾ ലയിപ്പിക്കുന്നതിന് മികച്ചതാണ്, വലിയ അറേകൾ കൈകാര്യം ചെയ്യുമ്പോൾ ഇതിന് ധാരാളം മെമ്മറി ഉപയോഗിക്കാനാകും.