à®ªà®¯à®©à¯à®ªà®à¯à®¤à¯à®¤ unshift() à®®à¯à®±à¯: array.unshift(element);.

à®®à®±à¯à®± à®à®±à¯à®ªà¯à®ªà¯à®à®³à¯à®à®©à¯ à®à®¤à¯ à®®à¯à®±à¯à®à®³à¯à®ªà¯ à®ªà®¯à®©à¯à®ªà®à¯à®¤à¯à®¤à®µà¯à®®à¯: array.push({ key: 'value' }); à®à®²à¯à®²à®¤à¯ array = [...array, { key: 'value' }];.

ஜாவாஸ்கிரிப்ட்: ஒரு

Paul Boyer

திங்கள், 8 ஜூலை, 2024 ’அன்று’ முற்பகல் 1:09:59

ஜாவாஸ்கிரிப்டில் சேர்க்கப்படும் மாஸ்டரிங் வரிசை

வரிசைகள் என்பது ஜாவாஸ்கிரிப்டில் உள்ள ஒரு அடிப்படை தரவு கட்டமைப்பாகும், இது டெவலப்பர்கள் தரவு சேகரிப்புகளை திறமையாக சேமிக்கவும் நிர்வகிக்கவும் அனுமதிக்கிறது. ஒரு பொதுவான பணி, சரங்கள் அல்லது எண்கள் போன்ற புதிய கூறுகளை ஏற்கனவே இருக்கும் வரிசையில் சேர்ப்பதாகும்.

உங்கள் ஜாவாஸ்கிரிப்ட் பயன்பாடுகளில் தரவை திறம்பட கையாள, ஒரு வரிசையில் உருப்படிகளை எவ்வாறு சரியாக இணைப்பது என்பதைப் புரிந்துகொள்வது முக்கியம். இந்தக் கட்டுரையில், ஒரு வரிசையில் உறுப்புகளைச் சேர்ப்பதற்கான பல்வேறு முறைகளை ஆராய்வோம், உங்கள் குறியீடு சுருக்கமாகவும் திறமையாகவும் இருப்பதை உறுதிசெய்கிறோம்.

கட்டளை	விளக்கம்
push()	அணிவரிசையின் முடிவில் ஒன்று அல்லது அதற்கு மேற்பட்ட கூறுகளைச் சேர்த்து, அணிவரிசையின் புதிய நீளத்தை வழங்கும்.
[...array, element]	ஸ்ப்ரெட் ஆபரேட்டரைப் பயன்படுத்தி, வரிசைக்கு உறுப்புகளை மிகவும் சுருக்கமான முறையில் சேர்க்கிறது.
concat()	அசல் வரிசையை மாற்றாமல் இரண்டு அல்லது அதற்கு மேற்பட்ட அணிவரிசைகள் அல்லது மதிப்புகளை ஒரு புதிய அணிவரிசையில் இணைக்கிறது.
console.log()	வலை கன்சோலுக்கு ஒரு செய்தியை வெளியிடுகிறது, இது வரிசை உள்ளடக்கங்களை பிழைத்திருத்துவதற்கும் ஆய்வு செய்வதற்கும் பயனுள்ளதாக இருக்கும்.

ஜாவாஸ்கிரிப்டில் இணைக்கப்படும் வரிசையின் விரிவான விளக்கம்

முதல் ஸ்கிரிப்ட் பயன்படுத்துகிறது push() ஒரு வரிசையில் உறுப்புகளைச் சேர்க்கும் முறை. ஆரம்பத்தில், ஒரு வெற்று வரிசை உருவாக்கப்பட்டது, பின்னர் ஒரு எண் மற்றும் சரம் போன்ற கூறுகள் இதைப் பயன்படுத்தி இணைக்கப்படுகின்றன. push() முறை. இந்த முறை நேரடியானது மற்றும் அதன் முடிவில் உறுப்புகளைச் சேர்ப்பதன் மூலம் அசல் வரிசையை நேரடியாக மாற்றியமைக்கிறது. இறுதிப் படி வரிசையை கன்சோலில் பதிவு செய்கிறது console.log(), புதுப்பிக்கப்பட்ட வரிசை உள்ளடக்கங்களைக் காட்டுகிறது. இந்த அணுகுமுறை திறமையானது மற்றும் அதன் எளிமை மற்றும் வரிசையின் நேரடி கையாளுதலுக்கு பரவலாகப் பயன்படுத்தப்படுகிறது.

இரண்டாவது ஸ்கிரிப்ட் ES6 ஸ்ப்ரெட் ஆபரேட்டரை அறிமுகப்படுத்துகிறது. இங்கே, ஸ்ப்ரெட் ஆபரேட்டரைப் பயன்படுத்தி புதிய உறுப்புகளைச் சேர்ப்பதன் மூலம் ஆரம்ப உறுப்புகளுடன் கூடிய வரிசை நீட்டிக்கப்படுகிறது [...array, element]. இந்த ஆபரேட்டர் ஏற்கனவே உள்ள வரிசையையும் புதிய உறுப்புகளையும் இணைத்து, அசல் வரிசையைப் பாதுகாத்து ஒரு புதிய வரிசையை உருவாக்குகிறது. முடிவு கன்சோலில் உள்நுழைந்து, வரிசை எவ்வாறு புதுப்பிக்கப்படுகிறது என்பதை விளக்குகிறது. இந்த முறை அதன் வாசிப்புத்திறன் மற்றும் மாறாத தன்மைக்கு விரும்பப்படுகிறது, புதிய, நீட்டிக்கப்பட்ட வரிசையை உருவாக்கும் போது அசல் அணிவரிசை மாறாமல் இருப்பதை உறுதி செய்கிறது.

வரிசை இணைப்பின் விரிவான பார்வை

மூன்றாவது ஸ்கிரிப்ட் பயன்படுத்துகிறது concat() ஒரு வரிசையில் உறுப்புகளைச் சேர்க்கும் முறை. ஆரம்ப கூறுகளைக் கொண்ட வரிசையுடன் தொடங்கி, தி concat() ஒரு தனிமத்தையும் பல உறுப்புகளையும் பின்னர் இணைக்க முறை பயன்படுத்தப்படுகிறது. போலல்லாமல் push(), concat() அசல் வரிசையை மாற்றாது ஆனால் அசல் மற்றும் புதிய கூறுகளை இணைத்து ஒரு புதிய வரிசையை வழங்குகிறது. இறுதி வரிசை கன்சோலில் அச்சிடப்படுகிறது console.log(). மாறாத தன்மைக்கு முன்னுரிமை அளிக்கும் போது இந்த முறை மிகவும் பயனுள்ளதாக இருக்கும், ஏனெனில் இது அசல் வரிசை மாறாமல் இருப்பதை உறுதி செய்கிறது.

பரவல் ஆபரேட்டர் மற்றும் concat() முறைகள் வரிசைகளுக்கு உறுப்புகளைச் சேர்க்க நெகிழ்வான மற்றும் மாறாத வழிகளை வழங்குகின்றன, அசல் வரிசையைப் பாதுகாப்பது முக்கியமான காட்சிகளுக்கு அவற்றைப் பொருத்தமானதாக ஆக்குகிறது. இந்த முறைகளைப் புரிந்துகொண்டு பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் ஜாவாஸ்கிரிப்டில் வரிசை கையாளுதல்களை திறமையாக நிர்வகிக்க முடியும், இது குறியீடு தெளிவு மற்றும் பராமரிப்பை உறுதி செய்கிறது. இந்த எடுத்துக்காட்டுகள் வரிசைகளைக் கையாள்வதில் ஜாவாஸ்கிரிப்ட்டின் பல்துறைத்திறனை எடுத்துக்காட்டுகின்றன, வரிசை கையாளுதல் பணிகளில் பல்வேறு தேவைகள் மற்றும் விருப்பங்களைப் பூர்த்தி செய்கின்றன.

ஜாவாஸ்கிரிப்டில் ஒரு அணிவரிசையில் உருப்படிகளைச் சேர்த்தல்

வெண்ணிலா ஜாவாஸ்கிரிப்டைப் பயன்படுத்துதல்

// Initializing an empty array
let array = [];

// Appending a number to the array
array.push(10);

// Appending a string to the array
array.push("Hello");

// Appending multiple elements to the array
array.push(20, "World");

// Logging the array to console
console.log(array);
// Output: [10, "Hello", 20, "World"]

ES6 ஸ்ப்ரெட் ஆபரேட்டரைப் பயன்படுத்தி ஒரு வரிசையில் கூறுகளைச் சேர்த்தல்

ES6 தொடரியல் பயன்படுத்துகிறது

// Initializing an array with initial elements
let array = [1, 2, 3];

// Appending a single element
array = [...array, 4];

// Appending multiple elements
array = [...array, 5, 6, 7];

// Logging the array to console
console.log(array);
// Output: [1, 2, 3, 4, 5, 6, 7]

ஒரு அணிவரிசையில் கூறுகளைச் சேர்க்க கான்காட் முறையைப் பயன்படுத்துதல்

ஜாவாஸ்கிரிப்ட்டின் இணைப்பு முறையைப் பயன்படுத்துதல்

// Initializing an array with initial elements
let array = ['a', 'b', 'c'];

// Appending a single element
array = array.concat('d');

// Appending multiple elements
array = array.concat('e', 'f');

// Logging the array to console
console.log(array);
// Output: ['a', 'b', 'c', 'd', 'e', 'f']

அடிப்படை இணைப்பிற்கு அப்பால் வரிசை முறைகளைப் புரிந்துகொள்வது

பயன்படுத்தி ஒரு அணிவரிசையில் உறுப்புகளைச் சேர்க்கும் போது push(), பரவல் ஆபரேட்டர், மற்றும் concat() பொதுவான மற்றும் திறமையான முறைகள், வரிசை கையாளுதலில் மற்ற நுட்பங்களும் பரிசீலனைகளும் உள்ளன. உதாரணமாக, தி unshift() முறையானது ஒரு வரிசையின் தொடக்கத்தில் கூறுகளைச் சேர்க்கலாம், ஏற்கனவே உள்ள கூறுகளை அதிக குறியீடுகளுக்கு மாற்றலாம். உறுப்புகளின் வரிசை முக்கியமானதாக இருக்கும் போது இது பயனுள்ளதாக இருக்கும், மேலும் தொடக்கத்தில் புதிய கூறுகள் தோன்ற வேண்டும். கூடுதலாக, Array.prototype.splice() ஒரு வரிசைக்குள் குறிப்பிட்ட நிலைகளில் கூறுகளைச் சேர்ப்பதற்கும் அகற்றுவதற்கும் பல்துறை அணுகுமுறையை வழங்குகிறது.

மற்றொரு முறை பயன்படுத்தப்படுகிறது Array.prototype.map() ஸ்ப்ரெட் ஆபரேட்டருடன் இணைந்து அல்லது concat() மிகவும் சிக்கலான செயல்பாடுகளுக்கு. இது ஒரே நேரத்தில் உறுப்புகளை மாற்றுவதற்கும் இணைப்பதற்கும் அனுமதிக்கிறது, குறிப்பாக செயல்பாட்டு நிரலாக்க முன்னுதாரணங்களில் பயனுள்ளதாக இருக்கும். மேலும், பல்வேறு முறைகளின் செயல்திறன் தாக்கங்களைப் புரிந்துகொள்வது பெரிய அளவிலான பயன்பாடுகளை மேம்படுத்துவதில் முக்கியமானதாக இருக்கும். உதாரணமாக, போது push() மற்றும் concat() பெரும்பாலான சந்தர்ப்பங்களில் திறமையானவை, பெரிய வரிசைகளில் அடிக்கடி மாற்றங்கள் இணைக்கப்பட்ட பட்டியல்கள் அல்லது மேல்நிலையைக் குறைக்க மேம்பட்ட வழிமுறைகள் போன்ற மாற்று தரவு கட்டமைப்புகளிலிருந்து பயனடையலாம்.

ஜாவாஸ்கிரிப்டில் வரிசைகளில் சேர்ப்பது பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்

ஒரு வரிசையில் ஒரே நேரத்தில் பல கூறுகளைச் சேர்ப்பது எப்படி?
நீங்கள் பயன்படுத்தலாம் push() பல வாதங்களை அனுப்பும் முறை: array.push(1, 2, 3); அல்லது ஸ்ப்ரெட் ஆபரேட்டரைப் பயன்படுத்தவும்: array = [...array, 1, 2, 3];.
என்ன வித்தியாசம் push() மற்றும் concat()?
push() அசல் வரிசையை அதன் முடிவில் உறுப்புகளைச் சேர்ப்பதன் மூலம் மாற்றியமைக்கிறது concat() அசல் வரிசையை மாற்றாமல் விட்டு, சேர்க்கப்பட்ட உறுப்புகளுடன் புதிய வரிசையை வழங்குகிறது.
வரிசையின் தொடக்கத்தில் ஒரு உறுப்பை எவ்வாறு சேர்ப்பது?
பயன்படுத்த unshift() முறை: array.unshift(element);.
ஸ்ப்ரெட் ஆபரேட்டர் (...) வரிசைகளில் என்ன செய்கிறது?
ஸ்ப்ரெட் ஆபரேட்டர் ஒரு வரிசையை தனிப்பட்ட உறுப்புகளாக விரிவுபடுத்துகிறது, இது கூடுதல் உறுப்புகளுடன் புதிய வரிசைகளை உருவாக்க உங்களை அனுமதிக்கிறது: let newArray = [...oldArray, newElement];.
நான் பயன்படுத்தி கொள்ளலாமா splice() ஒரு வரிசையில் உறுப்புகளைச் சேர்க்கவா?
ஆம், splice() ஒரு வரிசையில் எந்த நிலையிலும் கூறுகளைச் சேர்க்கலாம்: array.splice(index, 0, element);.
பெரிய வரிசைகளுக்கு உறுப்புகளைச் சேர்க்க மிகவும் திறமையான வழி எது?
பெரிய வரிசைகளுக்கு, பயன்படுத்துகிறது push() புதிய வரிசைகளை உருவாக்குவதை விட பொதுவாக மிகவும் திறமையானது concat() குறைந்த மேல்நிலை காரணமாக.
ஒரு வரிசையில் பொருட்களை எவ்வாறு இணைப்பது?
மற்ற உறுப்புகளுடன் அதே முறைகளைப் பயன்படுத்தவும்: array.push({ key: 'value' }); அல்லது array = [...array, { key: 'value' }];.
நிபந்தனையுடன் கூறுகளைச் சேர்க்க முடியுமா?
ஆம், ஒரு பயன்படுத்தவும் if சேர்ப்பதற்கு முன் நிலையை சரிபார்க்க அறிக்கை: if (condition) array.push(element);.
அணிவரிசையில் சேர்க்கும் போது மாறாத தன்மையை எவ்வாறு உறுதி செய்வது?
போன்ற புதிய அணிவரிசைகளை வழங்கும் முறைகளைப் பயன்படுத்தவும் concat() அல்லது ஸ்ப்ரெட் ஆபரேட்டர், அசல் வரிசையை மாற்றுவதைத் தவிர்க்க.
லூப்பில் உள்ள உறுப்புகளைச் சேர்க்க முடியுமா?
ஆம், பல கூறுகளைச் சேர்க்க நீங்கள் ஒரு வளையத்தைப் பயன்படுத்தலாம்: for (let i = 0; i < items.length; i++) array.push(items[i]);.

வரிசையை இணைக்கும் நுட்பங்களை சுருக்கவும்

ஜாவாஸ்கிரிப்டில் பயனுள்ள தரவு கையாளுதலுக்கு ஒரு அணிவரிசையில் கூறுகளை எவ்வாறு இணைப்பது என்பதைப் புரிந்துகொள்வது முக்கியம். இந்த வழிகாட்டி பல முறைகளை ஆராய்ந்தது, ஒவ்வொன்றும் தனித்துவமான நன்மைகளுடன். தி push() முறை நேரடியாக வரிசையை மாற்றியமைக்கிறது spread operator மற்றும் concat() முறைகள் புதிய வரிசைகளை உருவாக்கி, அசலைப் பாதுகாக்கின்றன. இந்த நுட்பங்களில் தேர்ச்சி பெறுவதன் மூலம், டெவலப்பர்கள் தங்கள் குறியீடு திறமையாகவும் பராமரிக்கக்கூடியதாகவும் இருப்பதை உறுதிசெய்ய முடியும், பல்வேறு வரிசை செயல்பாடுகளை எளிதாகக் கையாளும் திறன் கொண்டது.

ஜாவாஸ்கிரிப்ட்: ஒரு வரிசையில் கூறுகளைச் சேர்த்தல்