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

ஜாவாஸ்கிரிப்டில் ஒரு வரிசை என்றால் என்ன?

ஒரு வரிசை என்பது மதிப்புகளை சேகரிக்க உத்தரவிட்டார். இந்தத் தொகுப்பில் உள்ள மதிப்புகள் உறுப்புகள் என்று அழைக்கப்படுகின்றன. வரிசையில் உள்ள ஒவ்வொரு உறுப்புக்கும் அதன் சொந்த வரிசை எண் (எண்) உள்ளது, இது குறியீட்டு என அழைக்கப்படுகிறது. குறியீடுகள் 0 முதல் எண்ணப்படுகின்றன.

பின்வரும் படம் 5 கூறுகளைக் கொண்ட ஒரு எண் வரிசையைக் காட்டுகிறது. இந்த வரிசையின் கூறுகள் பின்வரும் தரவுகளைக் கொண்டிருக்கின்றன: 123 (குறியீட்டு 0), 7 (குறியீட்டு 1), 50 (குறியீட்டு 2), -9 (குறியீட்டு 3), 24 (குறியீட்டு 4).

ஒரு வரிசையை உருவாக்குதல் (அறிவித்தல்).

ஜாவாஸ்கிரிப்டில் வரிசைகளை உருவாக்குவது பொதுவாக இதைப் பயன்படுத்தி செய்யப்படுகிறது வரிசை எழுத்து.

ஒரு அணிவரிசை என்பது கமாவால் பிரிக்கப்பட்ட உறுப்புகளின் பட்டியலைக் கொண்ட சதுர அடைப்புக்குறிகளைக் கொண்டுள்ளது.

உதாரணத்திற்கு:

வர் வெறுமை = ; // வெற்று வரிசை var எண்கள் = ; // எண் வரிசை var arr = ; // பல்வேறு தரவு வகைகளைக் கொண்ட வரிசை

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

ஒரு குறிப்பிட்ட வரிசை உறுப்பு அதன் குறியீட்டால் அணுகப்படுகிறது. இந்த செயல்பாடு குறியீட்டு செயல்பாடு என்றும் அழைக்கப்படுகிறது.

உதாரணத்திற்கு:

// 3 கூறுகள் கொண்ட ஒரு வரிசையை உருவாக்கவும் var smartphoneColors = ["கருப்பு", "வெள்ளை", "சாம்பல்"]; // உலாவி கன்சோலில் ஸ்மார்ட்போன்கலர்ஸ் வரிசை உறுப்புகளின் மதிப்புகளை குறியீடுகள் 0 மற்றும் 2 console.log ("இன்டெக்ஸ் 0 உடன் ஸ்மார்ட்போன்கலர்ஸ் வரிசை உறுப்பு மதிப்பு: " + SmartphoneColors) // "இண்டெக்ஸ் 0: கருப்பு" console.log உடன் SmartphoneColors வரிசை உறுப்பு மதிப்பு ("இண்டெக்ஸ் 2 உடன் SmartphoneColors வரிசை உறுப்பு மதிப்பு: " + smartphoneColors); // "இண்டெக்ஸ் 0: கிரே உடன் SmartphoneColors வரிசை உறுப்பு மதிப்பு" // index 1 உடன் SmartphoneColors array உறுப்பின் மதிப்பை "சிவப்பு" SmartphoneColors = "சிவப்பு" என மாற்றவும்; // ["கருப்பு", "சிவப்பு", "சாம்பல்"] // இன்டெக்ஸ் 3 உடன் ஸ்மார்ட்போன்கலர்ஸ் வரிசை உறுப்பை "ப்ளூ" ஸ்மார்ட்ஃபோன்கலர்ஸ் = "ப்ளூ" மதிப்பிற்கு அமைக்கவும்; // ["கருப்பு", "சிவப்பு", "சாம்பல்", "நீலம்"]

நீங்கள் நிலையான மதிப்புகளை மட்டுமல்ல, வெளிப்பாடுகளையும் வரிசை உறுப்பு மதிப்புகளாகப் பயன்படுத்தலாம்:

Var நீளம்A = 7, அகலம்A = 5; var புள்ளி = ;

பொருள்களை வரிசை உறுப்பு மதிப்புகளாகப் பயன்படுத்தலாம்.

Var புள்ளிகள் = [ (x1: 5, y1: 3), (x1: 7, y1: 10), (x1: 12; y1: 0) ]; // 3 பொருள்களைக் கொண்ட வரிசை

வரிசையை உருவாக்க மற்றொரு வழிவரிசை கட்டமைப்பாளர் செயல்பாட்டை அழைப்பதைக் கொண்டுள்ளது.

வாதங்கள் இல்லாத ஒரு கன்ஸ்ட்ரக்டர் செயல்பாட்டு அழைப்பு வெற்று வரிசையை உருவாக்க பயன்படுகிறது.

Var காலி = புதிய வரிசை(); // வெற்று வரிசை

ஒரு வரிசையை உருவாக்கும் இந்த முறை ஒரு எழுத்துக்கு சமமானதாகும்.

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

Var arr = புதிய வரிசை(5); // 5 கூறுகளைக் கொண்ட வரிசை (உறுப்பு மதிப்புகள் வரையறுக்கப்படவில்லை)

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

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

நீளம் பண்பு (வரிசை நீளம்)

வரிசையின் நீளத்தை (உறுப்புகளின் எண்ணிக்கை) தீர்மானிப்பது நீளப் பண்புகளைப் பயன்படுத்தி செய்யப்படுகிறது.

//அரே செயல்பாடு var volumeHDDs = புதிய வரிசை ("500Gb","1Tb","2Tb") இல் உள்ள உறுப்புகளின் மதிப்புகளை பட்டியலிடுவதன் மூலம் ஒரு வரிசையை உருவாக்கவும்; //தொகுதிHDDs வரிசையின் நீளத்திற்கு நீளவரிசை மாறியை ஒதுக்கவும் var lengthArray = volumeHDDs.length;

ஒரு அணிவரிசையின் முதல் உறுப்பை எவ்வாறு பெறுவது

இந்த வரிசையின் சதுர அடைப்புக்குறிக்குள் எண் 0 ஐக் குறிப்பிடுவதன் மூலம் ஒரு வரிசையின் முதல் தனிமத்தின் மதிப்பைப் பெறுவது:

//3 உறுப்புகள் var volumeHDDs = புதிய வரிசை ("500Gb","1Tb","2Tb") கொண்ட வரிசையை உருவாக்குதல்; //வரிசையின் முதல் தனிமத்தின் மதிப்பைப் பெறுதல் var firstValue = volumeHDDs;

ஒரு அணிவரிசையின் கடைசி உறுப்பை எவ்வாறு பெறுவது

இந்த வரிசையின் சதுர அடைப்புக்குறிக்குள் array_name.length-1 என்ற வெளிப்பாட்டைக் குறிப்பிடுவதன் மூலம் வரிசையின் கடைசி உறுப்பின் மதிப்பு பெறப்படுகிறது:

//3 உறுப்புகள் var volumeHDDs = புதிய வரிசை ("500Gb","1Tb","2Tb") கொண்ட வரிசையை உருவாக்குதல்; //வரிசையின் கடைசி உறுப்பின் மதிப்பைப் பெறுதல் var lastValue = volumeHDDs;

ஒரு வரிசையின் மேல் திரும்ப திரும்ப

வரிசை உறுப்புகள் மூலம் திரும்புதல் ஒரு லூப்பைப் பயன்படுத்தி செய்யப்படுகிறது.

எடுத்துக்காட்டாக, வரிசையின் அனைத்து கூறுகளையும் மீண்டும் செய்து அவற்றின் மதிப்புகளை உலாவி கன்சோலில் (F12) காண்பிப்போம்:

//ஒரு வரிசை பெயரை உருவாக்குதல் மாணவர்கள், 4 உறுப்புகள் var nameStudents = புதிய வரிசை("Petya","Vasya","Kolya","Maxim"); //வரிசை உறுப்புகளை 0 முதல் வரிசை நீளம்-1 வரை மீண்டும் செய்யவும் (var i=0; i<= nameStudents.length-1; i++) { console.log(i+1 + " элемент массива = " + nameStudents[i]); }

நீக்க ஆபரேட்டரின் நோக்கம் என்ன?

டெலிட் ஆபரேட்டர் என்பது அணிவரிசையிலிருந்து ஒரு உறுப்பை அகற்றுவதற்கு அல்ல, ஆனால் கொடுக்கப்பட்ட வரிசை உறுப்புக்கு வரையறுக்கப்படாத மதிப்பை ஒதுக்குவதற்குப் பயன்படுத்தப்படுகிறது.

Var namePlanets = புதிய வரிசை("வீனஸ்","மெர்குரி","பூமி","செவ்வாய்"); namePlanets நீக்கவும்; (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

வரிசைகளுடன் வேலை செய்வதற்கான செயல்பாடுகள் (வரிசை பொருள் முறைகள்)

வரிசை பொருள் வரிசைகளுடன் பணிபுரிய பின்வரும் முறைகளை (செயல்பாடுகள்) கொண்டுள்ளது:

• மாற்றம்
• மாறாத
• துண்டு
• பிளவு
• பிளவு
• தலைகீழ்

புஷ் முறை (வரிசையின் முடிவில் ஒரு உறுப்பைச் சேர்த்தல்)

புஷ் முறையானது வரிசையின் முடிவில் ஒரு உறுப்பைச் சேர்க்க வடிவமைக்கப்பட்டுள்ளது. இந்த உறுப்பின் மதிப்பு இந்த முறைக்கு ஒரு அளவுருவாக குறிப்பிடப்பட்டுள்ளது. இதன் விளைவாக, புஷ் முறையானது அணிவரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கையை வழங்குகிறது, சேர்க்கப்பட்டதை கணக்கில் எடுத்துக்கொள்கிறது.

Var namePlanets = ["வீனஸ்", "மெர்குரி", "பூமி", "செவ்வாய்"]; namePlanets.push("வியாழன்"); // 5 console.log(namePlanets); // ["வீனஸ்", "புதன்", "பூமி", "செவ்வாய்", "வியாழன்"]

பாப் முறை (ஒரு வரிசையில் இருந்து கடைசி உறுப்பை நீக்குதல்)

பாப் முறையானது அணிவரிசையிலிருந்து கடைசி உறுப்பை அகற்ற வடிவமைக்கப்பட்டுள்ளது. இந்த முறைக்கு அளவுருக்கள் இல்லை. இதன் விளைவாக, இது வரிசையின் கடைசி (அகற்றப்பட்ட) உறுப்பின் மதிப்பை வழங்குகிறது.

Var namePlanets = ["வீனஸ்", "மெர்குரி", "பூமி", "செவ்வாய்"]; namePlanets.pop(); // "மார்ஸ்" console.log(namePlanets); // ["வீனஸ்", "புதன்", "பூமி"]

ஷிப்ட் முறை (வரிசையிலிருந்து முதல் உறுப்பை நீக்குதல்)

ஷிப்ட் முறையானது வரிசையில் இருந்து முதல் உறுப்பை அகற்ற வடிவமைக்கப்பட்டுள்ளது, அதாவது. குறியீட்டு 0 கொண்ட உறுப்பு. வரிசையின் மற்ற அனைத்து கூறுகளும் தொடக்கத்திற்கு மாற்றப்படுகின்றன, அதாவது. அவை ஒவ்வொன்றிற்கும் குறியீடு 1 ஆல் குறைக்கப்படுகிறது. இந்த முறையானது அகற்றப்பட்ட உறுப்பின் மதிப்பை அதன் விளைவாக வழங்குகிறது.

Var namePlanets = ["வீனஸ்", "மெர்குரி", "பூமி", "செவ்வாய்"]; namePlanets.shift(); // "வீனஸ்" console.log(namePlanets); // ["புதன்", "பூமி", "செவ்வாய்"]

unshift முறை (வரிசையின் தொடக்கத்தில் ஒரு உறுப்பைச் சேர்த்தல்)

அன்ஷிஃப்ட் முறையானது வரிசையின் தொடக்கத்தில் (மற்ற உறுப்புகளுக்கு முன்) ஒரு உறுப்பைச் சேர்க்க வடிவமைக்கப்பட்டுள்ளது. இந்த உறுப்பின் மதிப்பு இந்த முறைக்கு ஒரு அளவுருவாக குறிப்பிடப்பட்டுள்ளது. இதன் விளைவாக, இந்த முறை அணிவரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கையை வழங்குகிறது, சேர்க்கப்பட்டதை கணக்கில் எடுத்துக்கொள்கிறது.

Var namePlanets = ["புதன்", "பூமி", "செவ்வாய்", "வியாழன்"]; namePlanets.unshift("வீனஸ்"); // 5 console.log(namePlanets); // ["வீனஸ்", "புதன்", "பூமி", "செவ்வாய்", "வியாழன்"]

ஸ்லைஸ் முறை (வரிசையின் ஒரு பகுதியை நகலெடுப்பது)

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

ஸ்லைஸ் முறை 2 அளவுருக்கள் கொண்டது:

• 1 அளவுரு (தேவை) - உறுப்புகளை நகலெடுக்கத் தொடங்கும் உறுப்பின் குறியீட்டைக் குறிக்கும் நோக்கம் கொண்டது;
• அளவுரு 2 (விரும்பினால்) - நகலெடுக்க வேண்டிய உறுப்பின் குறியீட்டைக் குறிக்கும் நோக்கம் கொண்டது (இந்த விஷயத்தில், இது புதிய வரிசையில் சேர்க்கப்படவில்லை). நீங்கள் அதைக் குறிப்பிடவில்லை என்றால், குறிப்பிட்ட அணிவரிசையின் இறுதி வரை உள்ள கூறுகள் நகலெடுக்கப்படும்.

var namePlanets = ["வீனஸ்", "புதன்", "பூமி", "செவ்வாய்", "வியாழன்"]; var newNamePlanets = namePlanets.slice(2, 4); // ["பூமி", "செவ்வாய்"]

பிளவு முறை (வரிசையின் உள்ளடக்கங்களை மாற்றுதல்)

ஸ்பைஸ் முறையானது ஒரு வரிசையின் உள்ளடக்கங்களை மாற்ற வடிவமைக்கப்பட்டுள்ளது. அணிவரிசையில் உறுப்புகளைச் சேர்ப்பதற்கும் அவற்றை அகற்றுவதற்கும் இதைப் பயன்படுத்தலாம்.

பிளவு முறையின் தொடரியல்:

Array.splice(startIndex, deleteCount [, element1[, element2[, ...]]]); /* startIndex (தேவை) - வரிசையை மாற்றத் தொடங்கும் உறுப்பின் தொடக்கக் குறியீடு. வரிசையின் நீளத்தை விட அதிகமான எண்ணை startIndex எனக் குறிப்பிட்டால், தொடக்க அட்டவணையானது வரிசையின் முடிவில் அமைக்கப்படும். எதிர்மறை எண்ணை தொடக்க அட்டவணையாகக் குறிப்பிட்டால், தொடக்க உறுப்பு முடிவில் இருந்து கணக்கிடப்படும். deleteCount (தேவை) - வரிசையில் இருந்து எத்தனை உறுப்புகள் நீக்கப்பட வேண்டும் என்பதைக் குறிக்கும் எண். அணிவரிசையிலிருந்து உறுப்புகளை நீக்க வேண்டிய அவசியமில்லை என்றால், deleteCount ஐ 0 ஆக அமைக்க வேண்டும். இதற்குப் பிறகு, அணிவரிசையில் சேர்க்க குறைந்தபட்சம் ஒரு புதிய உறுப்பையாவது குறிப்பிட வேண்டும். startIndex இலிருந்து தொடங்கி, வரிசையில் மீதமுள்ள உறுப்புகளின் எண்ணிக்கையை விட அதிகமாக இருக்கும் ஒரு எண்ணை deleteCount என நீங்கள் குறிப்பிட்டால், இந்தச் சந்தர்ப்பத்திலும் அவை நீக்கப்படும் (அதாவது, தொடக்க அட்டவணையில் இருந்து தொடங்கி, வரிசையின் இறுதி வரை உள்ள அனைத்து கூறுகளும்) உறுப்பு1, உறுப்பு2, .. (விரும்பினால்) - அணிவரிசையில் சேர்க்க வேண்டிய உறுப்புகள். */

ஸ்பைஸ் முறையைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டுகள்.

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

Var namePlanets = ["வீனஸ்", "மெர்குரி", "பூமி", "செவ்வாய்"]; namePlanets.splice(2, 2); //["பூமி", "செவ்வாய்"] console.log(namePlanets); // ["வீனஸ்", "புதன்"]

ஒரு அணிவரிசையிலிருந்து ஒரு உறுப்பை அகற்றி, அதில் புதியவற்றைச் சேர்க்க ஸ்பைஸ் முறையைப் பயன்படுத்துதல்.

Var namePlanets = ["வீனஸ்", "மெர்குரி", "பூமி", "செவ்வாய்"]; namePlanets.splice(1, 1, "யுரேனஸ்", "நெப்டியூன்", "சனி"); // ["மெர்குரி"] console.log(namePlanets); // ["வீனஸ்", "யுரேனஸ்", "நெப்டியூன்", "சனி", "பூமி", "செவ்வாய்"]

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

Var namePlanets = ["வியாழன்", "சனி", "யுரேனஸ்"]; namePlanets.splice(0, 0, "வீனஸ்", "மெர்குரி", "பூமி", "செவ்வாய்"); // console.log(namePlanets); // ["வீனஸ்", "புதன்", "பூமி", "செவ்வாய்", "வியாழன்", "சனி", "யுரேனஸ்"]

சேரும் முறை (வரிசையை சரமாக மாற்றுதல்)

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

சேரும் முறை தொடரியல்:

Array.join(); /* பிரிப்பான் (விரும்பினால்) - ஒவ்வொரு வரிசை உறுப்புக்கும் இடையில் இணைக்கும் சரமாகப் பயன்படுத்தப்படும் பிரிப்பான். இந்த அளவுரு குறிப்பிடப்படவில்லை என்றால், "," இணைக்கும் சரமாகப் பயன்படுத்தப்படும். நீங்கள் ஒரு வெற்று சரத்தை அளவுருவாகக் குறிப்பிட்டால், திரும்பிய சரத்தில் உள்ள வரிசை உறுப்புகள் எதனாலும் பிரிக்கப்படாது */

Var பெர்ரி = ["திராட்சை", "திராட்சை", "திராட்சை வத்தல்", "ரோஸ் ஹிப்"]; var பெர்ரிStr1 = பெர்ரி.சேர்(); // "திராட்சை, திராட்சை, திராட்சை வத்தல், ரோஸ் ஹிப்ஸ்" var பெர்ரிStr2 = பெர்ரி.join(""); // "GrapesGrapesCurrantRosehip" var பெர்ரிStr3 = பெர்ரி.ஜாயின்(", "); // "திராட்சை, திராட்சை, திராட்சை வத்தல், ரோஸ்ஷிப்ஸ்" var பெர்ரிStr4 = பெர்ரி.சேர்(" + "); // "திராட்சை + திராட்சை + திராட்சை வத்தல் + ரோஸ் ஹிப்ஸ்"

நீங்கள் சரம் அல்லாத ஒன்றை பிரிப்பானாகப் பயன்படுத்தினால், அது சரமாக மாற்றப்படும்.

Var பெர்ரி = ["திராட்சை", "திராட்சை", "திராட்சை வத்தல்", "ரோஸ் ஹிப்"]; var பெர்ரி Str1 = பெர்ரி. சேர (தவறான); // "GrapesfalseGrapesfalseCurrantfalseRosehip" var பெர்ரிStr2 = பெர்ரி.ஜோயின்(4/2); // "Grapes2Grapes2Currant2Rose Hip" வரிசை உறுப்புகள் பூஜ்யமாகவோ அல்லது மதிப்பாக வரையறுக்கப்படாதவையோ வெற்று சரத்திற்கு அனுப்பப்படும். var arr = ; var arrStr = arr.join(", "); // "0, 5, -4"

ஒரு சரத்தை அணிவரிசையாக மாற்றுதல் - பிளவு

பிளவு முறை ஒரு சரத்தை அணிவரிசையாக மாற்ற வடிவமைக்கப்பட்டுள்ளது. இந்த முறைக்கு ஒரு அளவுரு உள்ளது, அதன் அடிப்படையில் நீங்கள் ஒரு சரத்தை குறிப்பிடலாம், அதன் அடிப்படையில் இந்த சரம் சரங்களின் வரிசையாக பிரிக்கப்படும்.

Var strElementComputers = "System unit, Monitor, Keyboard, Mouse, Speakers, Printer"; var elementComputers = strElementComputers.split(", "); console.log("வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை: " + elementComputers.length); (var i=0; i<= elementComputers.length-1; i++) { console.log(i + " элемент массива = " + elementComputers[i]); }

வரிசை உறுப்புகளை தலைகீழ் வரிசையில் மறுவரிசைப்படுத்துதல் - தலைகீழ்

தலைகீழ் முறை வரிசை உறுப்புகளை தலைகீழ் வரிசையில் மறுவரிசைப்படுத்த வடிவமைக்கப்பட்டுள்ளது.

Var namePlanets = புதிய வரிசை("வீனஸ்","மெர்குரி","பூமி","செவ்வாய்"); namePlanets.reverse(); console.log("வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை: " + namePlanets.length); (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

வரிசை உறுப்புகளை வரிசைப்படுத்துதல் - வரிசைப்படுத்துதல்

வரிசை கூறுகளை வரிசைப்படுத்த வரிசை முறை பயன்படுத்தப்படுகிறது. முன்னிருப்பாக, இந்த முறை வரிசையை சரங்களாக வரிசைப்படுத்துகிறது.

Var namePlanets = புதிய வரிசை("வீனஸ்","மெர்குரி","பூமி","செவ்வாய்"); namePlanets.sort(); console.log("வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை: " + namePlanets.length); (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

06/21/2017 12:17

JavaScript இல் உள்ள பொருட்களின் வரிசையின் அளவைக் கணக்கிட, வரிசையின் நீளப் பண்புகளைப் பயன்படுத்தவும்.

Var arr = ["முதல்", "இரண்டாவது"]; console.log(arr.length); // 2

ஜாவாஸ்கிரிப்டில் உள்ள வரிசைகள் காணாமல் போன குறியீடுகளைக் கொண்டிருக்கலாம். உதாரணத்திற்கு

வர் அர்ர் = ; arr = "முதல்"; arr = "இரண்டாவது";

நீளப் பண்பு அணிவரிசையின் அதிகபட்ச குறியீட்டை + 1 ஐ வழங்குகிறது. அதாவது. கொடுக்கப்பட்ட எடுத்துக்காட்டில், நீளம் = 5.

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

Array.prototype.count = செயல்பாடு())(var முடிவு = 0; for(var i = 0; i< this.length; i++) if (this[i] != undefined) result++; return result; }

பயன்பாட்டு உதாரணம்

வர் அர்ர் = ; arr = "முதல்"; arr = "இரண்டாவது"; console.log(arr.count()); //2

நீளமான சொத்திற்கு மதிப்பையும் நீங்கள் ஒதுக்கலாம். இது ஏற்கனவே உள்ள வரிசையின் நீளத்தைக் குறைக்க உங்களை அனுமதிக்கிறது.

Var arr = ["முதல்", "இரண்டாவது", "மூன்றாவது"]; arr.length = 2; console.log(arr); // ["முதல்", "இரண்டாவது"]

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

வரிசைகள் வழக்கமான பொருள்கள், எனவே ஒரு வரிசையின் அளவை பைட்டுகளில் கணக்கிடுவது வேறு எந்த பொருளின் அளவையும் கணக்கிடுவதை விட வேறுபட்டதல்ல. துரதிர்ஷ்டவசமாக, ஜாவாஸ்கிரிப்ட் அளவைக் கணக்கிடுவதற்கான API ஐ வழங்கவில்லை, எனவே அதை நீங்களே கணக்கிட வேண்டும். இது பின்வருமாறு செய்யப்படுகிறது: பொருளின் அனைத்து பண்புகளையும் நாங்கள் பார்க்கிறோம்; சொத்து ஒரு பழமையான வகையாக இருந்தால், இந்த வகையின் ஒரு நிகழ்வின் அளவை ஒட்டுமொத்த முடிவில் சேர்க்கிறோம்; சொத்து ஒரு பொருளைக் கொண்டிருந்தால், நாங்கள் மீண்டும் மீண்டும் கணக்கிடுகிறோம். இதனுடைய அளவு.

Function sizeOf(obj) (var bytes = 0; if(obj !== null && obj !== undefined) ( switch(typeof obj) ( case "number": bytes += 8; break; case "string": bytes += obj.length * 2; முறிவு; வழக்கு "பூலியன்": பைட்டுகள் += 4; உடைப்பு; வழக்கு "பொருள்": for(var key in obj) ( bytes += sizeOf(obj); ) முறிவு; ) ) திரும்ப பைட்டுகள் ;);

முறை துல்லியமாக இல்லை மற்றும் பல சிக்கல்களைக் கொண்டுள்ளது - எடுத்துக்காட்டாக, முடிவில்லாத சுழற்சியில் செல்ல வாய்ப்பு உள்ளது.

கடைசியாக புதுப்பிக்கப்பட்டது: 03/26/2018

வரிசை பொருள் ஒரு வரிசையைக் குறிக்கிறது மற்றும் பல பண்புகளையும் முறைகளையும் வழங்குகிறது, இதன் மூலம் நாம் வரிசையை கையாள முடியும்.

ஒரு வரிசையைத் தொடங்குதல்

சதுர அடைப்புக்குறிகள் அல்லது வரிசை கட்டமைப்பாளரைப் பயன்படுத்தி வெற்று வரிசையை உருவாக்கலாம்:

Var பயனர்கள் = புதிய வரிசை(); var மக்கள் = ; console.log(பயனர்கள்); // Array console.log(மக்கள்); //வரிசை

குறிப்பிட்ட எண்ணிக்கையிலான உறுப்புகளைக் கொண்ட வரிசையை நீங்கள் உடனடியாக துவக்கலாம்:

Var பயனர்கள் = புதிய வரிசை("டாம்", "பில்", "ஆலிஸ்"); var மக்கள் = ["சாம்", "ஜான்", "கேட்"]; console.log(பயனர்கள்); // ["டாம்", "பில்", "ஆலிஸ்"] console.log(people); // ["சாம்", "ஜான்", "கேட்"]

நீங்கள் ஒரு வரிசையை வரையறுத்து அதில் புதிய கூறுகளைச் சேர்க்கலாம்:

Var பயனர்கள் = புதிய வரிசை(); பயனர்கள் = "டாம்"; பயனர்கள் = "கேட்"; console.log(பயனர்கள்); // "டாம்" console.log(பயனர்கள்); // வரையறுக்கப்படவில்லை

முன்னிருப்பாக வரிசை பூஜ்ஜிய நீளத்துடன் உருவாக்கப்பட்டாலும் பரவாயில்லை. குறியீடுகளைப் பயன்படுத்தி, ஒரு குறிப்பிட்ட குறியீட்டில் ஒரு வரிசையில் ஒன்று அல்லது மற்றொரு உறுப்பை மாற்றலாம்.

நீளம்

வரிசையின் நீளத்தைக் கண்டறிய, நீளப் பண்புகளைப் பயன்படுத்தவும்:

வர் பழம் = புதிய வரிசை(); பழம் = "ஆப்பிள்கள்"; பழம் = "பேரி"; பழம் = "பிளம்ஸ்"; document.write("வரிசை பழத்தில் " + fruit.length + " உறுப்பு:
"); (var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

உண்மையில், வரிசையின் நீளம் கடைசி உறுப்பு மற்றும் ஒன்றின் குறியீடாக இருக்கும். உதாரணத்திற்கு:

Var பயனர்கள் = புதிய வரிசை(); // அணிவரிசை பயனர்களில் 0 கூறுகள் உள்ளன = "டாம்"; பயனர்கள் = "கேட்"; பயனர்கள் = "சாம்"; (var i=0; i

உலாவி வெளியீடு:

டாம் கேட் வரையறுக்கப்படாத சாம்

குறியீடுகள் 2 மற்றும் 3க்கான உறுப்புகளை நாங்கள் சேர்க்கவில்லை என்ற போதிலும், இந்த வழக்கில் வரிசையின் நீளம் எண் 5 ஆக இருக்கும். 2 மற்றும் 3 குறியீடுகளைக் கொண்ட உறுப்புகள் வரையறுக்கப்படாத மதிப்பைக் கொண்டிருக்கும் .

ஒரு வரிசையை நகலெடுக்கிறது. துண்டு ()

ஒரு வரிசையை நகலெடுப்பது ஆழமற்ற அல்லது ஆழமற்ற (ஆழமான நகல்) மற்றும் ஆழமான (ஆழமான நகல்) ஆக இருக்கலாம்.

மேலோட்டமான நகலெடுப்பிற்கு, ஒரு வரிசையை சேமிக்கும் மற்றொரு மாறியின் மதிப்பை ஒரு மாறிக்கு ஒதுக்கினால் போதும்:

Var பயனர்கள் = ["டாம்", "சாம்", "பில்"]; console.log(பயனர்கள்); // ["டாம்", "சாம்", "பில்"] var மக்கள் = பயனர்கள்; // ஆழமற்ற நகலெடுக்கும் மக்கள் = "மைக்"; // இரண்டாவது உறுப்பு console.log (பயனர்கள்) ஐ மாற்றவும்; // ["டாம்", "மைக்", "பில்"]

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

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

Var பயனர்கள் = ["டாம்", "சாம்", "பில்"]; console.log(பயனர்கள்); // ["டாம்", "சாம்", "பில்"] var மக்கள் = பயனர்கள்.ஸ்லைஸ்(); // ஆழமான நகல் மக்கள் = "மைக்"; // இரண்டாவது உறுப்பு console.log (பயனர்கள்) ஐ மாற்றவும்; // ["டாம்", "சாம்", "பில்"] console.log(people); // ["டாம்", "மைக்", "பில்"]

இந்த வழக்கில், நகலெடுத்த பிறகு, மாறிகள் வெவ்வேறு வரிசைகளை சுட்டிக்காட்டும், மேலும் அவற்றை ஒருவருக்கொருவர் தனித்தனியாக மாற்றலாம்.

ஸ்லைஸ்() முறையானது வரிசையின் ஒரு பகுதியை நகலெடுக்க உங்களை அனுமதிக்கிறது:

Var பயனர்கள் = ["டாம்", "சாம்", "பில்", "ஆலிஸ்", "கேட்"]; var மக்கள் = பயனர்கள்.slice(1, 4); console.log(மக்கள்); // ["சாம்", "பில்", "ஆலிஸ்"]

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

மிகுதி()

புஷ்() முறையானது வரிசையின் முடிவில் ஒரு உறுப்பைச் சேர்க்கிறது:

வர் பழம் = ; பழம்.புஷ்("ஆப்பிள்கள்"); பழம்.புஷ்("பேரி"); பழம்.புஷ்("பிளம்ஸ்"); fruit.push("செர்ரி","பாதாமி
"); document.write(பழம்); // ஆப்பிள்கள், பேரிக்காய், பிளம்ஸ், செர்ரி, apricots

பாப்()

பாப்() முறையானது வரிசையிலிருந்து கடைசி உறுப்பை நீக்குகிறது:

வர் பழம் = ["ஆப்பிள்கள்", "பேரி", "பிளம்ஸ்"]; var lastFruit = fruit.pop(); // வரிசை ஆவணத்திலிருந்து கடைசி உறுப்பைப் பிரித்தெடுக்கவும்.write(lastFruit + "
"); document.write("வரிசை பழத்தில் " + fruit.length + " உறுப்பு:
"); (var i=0; i ");

உலாவி வெளியீடு:

பிளம்ஸ் பழ வரிசையில் 2 கூறுகள் உள்ளன: ஆப்பிள் பேரிக்காய்

shift()

ஷிப்ட்() முறையானது வரிசையிலிருந்து முதல் உறுப்பை மீட்டெடுத்து நீக்குகிறது:

வர் பழம் = ["ஆப்பிள்கள்", "பேரி", "பிளம்ஸ்"]; var firstFruit = fruit.shift(); document.write(firstFruit + "
"); document.write("வரிசை பழத்தில் " + fruit.length + " உறுப்பு:
"); (var i=0; i ");

உலாவி வெளியீடு:

ஆப்பிள்கள் பழ வரிசையில் 2 கூறுகள் உள்ளன: பேரிக்காய் பிளம்ஸ்

மாற்றப்படாத ()

unshift() முறையானது வரிசையின் தொடக்கத்தில் ஒரு புதிய உறுப்பைச் சேர்க்கிறது:

வர் பழம் = ["ஆப்பிள்கள்", "பேரி", "பிளம்ஸ்"]; fruit.unshift("apricots"); document.write(பழம்);

உலாவி வெளியீடு:

ஆப்ரிகாட், ஆப்பிள், பேரிக்காய், பிளம்ஸ்

குறியீட்டின் மூலம் ஒரு உறுப்பை நீக்குதல். பிளவு()

Splice() முறையானது ஒரு குறிப்பிட்ட குறியீட்டில் உள்ள உறுப்புகளை நீக்குகிறது. எடுத்துக்காட்டாக, மூன்றாவது குறியீட்டிலிருந்து கூறுகளை நீக்குதல்:

Var பயனர்கள் = ["டாம்", "சாம்", "பில்", "ஆலிஸ்", "கேட்"]; var நீக்கப்பட்டது = பயனர்கள்.splice(3); console.log(நீக்கப்பட்டது); // [ "ஆலிஸ்", "கேட்" ] console.log(பயனர்கள்); // [ "டாம்", "சாம்", "பில்" ]

ஸ்லைஸ் முறை அகற்றப்பட்ட கூறுகளை வழங்குகிறது.

இந்த வழக்கில், வரிசையின் தொடக்கத்தில் இருந்து நீக்குதல் நிகழ்கிறது. நீங்கள் எதிர்மறை குறியீட்டைக் கடந்துவிட்டால், அணிவரிசையின் முடிவில் இருந்து நீக்குதல் செய்யப்படும். எடுத்துக்காட்டாக, கடைசி உறுப்பை அகற்றுவோம்:

Var பயனர்கள் = ["டாம்", "சாம்", "பில்", "ஆலிஸ்", "கேட்"]; var நீக்கப்பட்டது = பயனர்கள்.splice(-1); console.log(நீக்கப்பட்டது); // [ "கேட்" ] console.log(பயனர்கள்); // [ "டாம்", "சாம்", "பில்", "ஆலிஸ்" ]

முறையின் கூடுதல் பதிப்பு, நீக்குவதற்கான இறுதிக் குறியீட்டைக் குறிப்பிட உங்களை அனுமதிக்கிறது. எடுத்துக்காட்டாக, முதல் முதல் மூன்றாவது குறியீட்டை நீக்கலாம்:

Var பயனர்கள் = ["டாம்", "சாம்", "பில்", "ஆலிஸ்", "கேட்"]; var நீக்கப்பட்டது = பயனர்கள். splice(1,3); console.log(நீக்கப்பட்டது); // [ "சாம்", "பில்", "ஆலிஸ்" ] console.log(users); // [ "டாம்", "கேட்" ]

ஸ்பைஸ் முறையின் மற்றொரு பதிப்பு நீக்கப்பட்ட உறுப்புகளுக்குப் பதிலாக புதிய கூறுகளைச் செருக அனுமதிக்கிறது:

Var பயனர்கள் = ["டாம்", "சாம்", "பில்", "ஆலிஸ்", "கேட்"]; var நீக்கப்பட்டது = பயனர்கள்.splice(1,3, "Ann", "Bob"); console.log(நீக்கப்பட்டது); // [ "சாம்", "பில்", "ஆலிஸ்" ] console.log(users); // [ "டாம்", "ஆன்", "பாப்", "கேட்" ]

இந்த வழக்கில், 1 முதல் 3 வரையிலான குறியீடுகளில் இருந்து மூன்று கூறுகளை நீக்கிவிட்டு, அதற்குப் பதிலாக இரண்டு உறுப்புகளைச் செருகுவோம்.

தொடர்பு ()

வரிசைகளை இணைக்க concat() முறை பயன்படுத்தப்படுகிறது:

வர் பழம் = ["ஆப்பிள்கள்", "பேரி", "பிளம்ஸ்"]; var காய்கறிகள் = ["தக்காளி", "வெள்ளரிகள்", "உருளைக்கிழங்கு"]; var பொருட்கள் = பழங்கள். concat(காய்கறிகள்); (var i=0; i< products.length; i++) document.write(products[i] + "
");

இந்த வழக்கில், ஒரே மாதிரியான வரிசைகளை மட்டும் இணைக்க வேண்டிய அவசியமில்லை. பல்வேறு வகைகள் சாத்தியம்:

வர் பழம் = ["ஆப்பிள்கள்", "பேரி", "பிளம்ஸ்"]; var விலைகள் = ; var பொருட்கள் = fruit.concat(prices);

சேர ()

join() முறையானது ஒரு வரிசையின் அனைத்து கூறுகளையும் ஒரு சரமாக இணைக்கிறது:

வர் பழம் = ["ஆப்பிள்", "பேரி", "பிளம்ஸ்", "ஆப்ரிகாட்", "பீச்"]; var fruitString = fruit.join(", "); document.write(fruitString);

வரிசை உறுப்புகளுக்கு இடையே பிரிப்பான் மூலம் join() முறை அனுப்பப்படுகிறது. இந்த வழக்கில், ஒரு கமா மற்றும் ஒரு இடைவெளி (", ") பிரிப்பானாகப் பயன்படுத்தப்படும்.

வகைபடுத்து()

வரிசை() முறையானது வரிசையை ஏறுவரிசையில் வரிசைப்படுத்துகிறது:

வர் பழம் = ["ஆப்பிள்", "பேரி", "பிளம்ஸ்", "ஆப்ரிகாட்", "பீச்"]; பழம்.வகை(); (var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

உலாவி வெளியீடு:

Apricots pears peaches பிளம்ஸ் ஆப்பிள்கள்

தலைகீழ் ()

தலைகீழ் () முறை வரிசையை பின்னோக்கி மாற்றுகிறது:

வர் பழம் = ["ஆப்பிள்", "பேரி", "பிளம்ஸ்", "ஆப்ரிகாட்", "பீச்"]; பழம்.தலைகீழ்(); (var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

உலாவி வெளியீடு:

பீச் ஆப்ரிகாட் பிளம்ஸ் பேரிக்காய் ஆப்பிள்கள்

வரிசை () முறையுடன் இணைந்து, நீங்கள் வரிசையை இறங்கு வரிசையில் வரிசைப்படுத்தலாம்:

வர் பழம் = ["ஆப்பிள்", "பேரி", "பிளம்ஸ்", "ஆப்ரிகாட்", "பீச்"]; பழம்.வகை().தலைகீழ்(); (var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

உலாவி வெளியீடு:

ஆப்பிள்கள் பிளம்ஸ் பீச் பேரிக்காய் apricots

ஒரு உறுப்பு குறியீட்டைக் கண்டறிதல்

indexOf() மற்றும் lastIndexOf() முறைகள் வரிசையில் உள்ள உறுப்பின் முதல் மற்றும் கடைசி சேர்க்கையின் குறியீட்டை வழங்கும். உதாரணத்திற்கு:

வர் பழம் = ["ஆப்பிள்", "பேரி", "பிளம்ஸ்", "ஆப்பிள்", "பேரி"]; var firstIndex = fruit.indexOf("apples"); var lastIndex = fruit.lastIndexOf("apples"); var otherIndex = fruit.indexOf("cherries"); document.write(firstIndex); // 0 document.write(lastIndex); // 3 document.write(otherIndex); // -1

முதல்இண்டெக்ஸ் 0 மதிப்பைக் கொண்டுள்ளது, ஏனெனில் வரிசையில் "ஆப்பிள்ஸ்" வரியின் முதல் சேர்க்கை குறியீட்டு 0 இல் உள்ளது, கடைசியானது குறியீட்டு 3 இல் உள்ளது.

உறுப்பு அணிவரிசையில் இல்லை என்றால், இந்த வழக்கில் indexOf() மற்றும் lastIndexOf() முறைகள் -1 மதிப்பை வழங்கும்.

ஒவ்வொரு()

எல்லா உறுப்புகளும் ஒரு குறிப்பிட்ட நிபந்தனையுடன் பொருந்துமா என்பதை ஒவ்வொரு() முறை சரிபார்க்கிறது:

வர் எண்கள் = [ 1, -12, 8, -4, 25, 42 ]; செயல்பாட்டு நிலை(மதிப்பு, குறியீட்டு, வரிசை) (var முடிவு = தவறு; என்றால் (மதிப்பு > 0) (முடிவு = உண்மை; ) முடிவு திரும்பவும்; ); var pass = numbers.every(condition); document.write(passed); //பொய்

ஒவ்வொரு() முறையானது நிபந்தனையை ஒரு அளவுருவாகக் குறிக்கும் ஒரு செயல்பாடு அனுப்பப்படுகிறது. இந்த செயல்பாடு மூன்று அளவுருக்களை எடுக்கும்:

செயல்பாட்டு நிலை(மதிப்பு, குறியீட்டு, வரிசை) ( )

மதிப்பு அளவுரு தற்போதைய வரிசை உறுப்பை மீண்டும் குறிப்பிடுகிறது, குறியீட்டு அளவுரு அந்த உறுப்பின் குறியீட்டைக் குறிக்கிறது, மற்றும் வரிசை அளவுரு வரிசைக்கு ஒரு குறிப்பை அனுப்புகிறது.

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

இதன் விளைவாக, numbers.every(condition) முறை என்று அழைக்கப்படும் போது, ​​அது எண்கள் வரிசையின் அனைத்து உறுப்புகளையும் மீண்டும் மீண்டும் செய்து, அவற்றை ஒவ்வொன்றாக நிபந்தனை செயல்பாட்டிற்கு அனுப்புகிறது. இந்தச் சார்பு எல்லா உறுப்புகளுக்கும் சரி எனத் தரப்பட்டால், ஒவ்வொரு() முறையும் சரி என்று திரும்பும். குறைந்தபட்சம் ஒரு உறுப்பு நிபந்தனையுடன் பொருந்தவில்லை என்றால், ஒவ்வொரு() முறையும் தவறானது .

சில()

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

வர் எண்கள் = [ 1, -12, 8, -4, 25, 42 ]; செயல்பாட்டு நிலை(மதிப்பு, குறியீட்டு, வரிசை) (var முடிவு = தவறானது; என்றால் (மதிப்பு === 8) (முடிவு = உண்மை; ) திரும்ப முடிவு; ); var pass = numbers.some(condition); //உண்மை

வடிகட்டி()

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

வர் எண்கள் = [ 1, -12, 8, -4, 25, 42 ]; செயல்பாட்டு நிலை(மதிப்பு, குறியீட்டு, வரிசை) (var முடிவு = தவறு; என்றால் (மதிப்பு > 0) (முடிவு = உண்மை; ) முடிவு திரும்பவும்; ); var filteredNumbers = numbers.filter(condition); (var i=0; i< filteredNumbers.length; i++) document.write(filteredNumbers[i] + "
");

உலாவி வெளியீடு:

1 8 25 42

ஒவ்வொரு() மற்றும் வரைபடம்()

forEach() மற்றும் map() முறைகள் தனிமங்களின் மீது மீண்டும் செயல்படுகின்றன மற்றும் அவற்றில் சில செயல்பாடுகளைச் செய்கின்றன. எடுத்துக்காட்டாக, ஒரு வரிசையில் உள்ள எண்களின் சதுரங்களைக் கணக்கிட, பின்வரும் குறியீட்டைப் பயன்படுத்தலாம்:

வர் எண்கள் = [1, 2, 3, 4, 5, 6]; (var i = 0; i "); }

ஆனால் forEach() முறையைப் பயன்படுத்தி நீங்கள் இந்த கட்டுமானத்தை எளிதாக்கலாம்:

வர் எண்கள் = [1, 2, 3, 4, 5, 6]; செயல்பாடு சதுரம்(மதிப்பு, குறியீட்டு, வரிசை) ( var முடிவு = மதிப்பு * மதிப்பு; document.write("" + மதிப்பு + " எண்ணின் வர்க்கம் " + முடிவு + "
"); );எண்கள்.ஒவ்வொருக்கும்(சதுரம்);

forEach() முறையானது, அதே செயல்பாட்டை ஒரு அளவுருவாக எடுத்துக்கொள்கிறது, அதில், உறுப்புகளின் மீது மீண்டும் செய்யும் போது, ​​தற்போதைய உறுப்பு மீண்டும் செயல்படுத்தப்பட்டு, அதன் மீது செயல்பாடுகள் செய்யப்படுகின்றன.

வரைபடம்() முறை forEach முறைக்கு ஒத்ததாகும்; இது வரிசையின் உறுப்புகளில் செயல்பாடுகளைச் செய்யும் ஒரு செயல்பாட்டினை ஒரு அளவுருவாக எடுத்துக்கொள்கிறது, ஆனால் வரைபடம்() முறை வரிசை உறுப்புகளின் செயல்பாடுகளின் முடிவுகளுடன் ஒரு புதிய வரிசையை வழங்குகிறது.

எடுத்துக்காட்டாக, வரிசையில் உள்ள எண்களின் சதுரங்களைக் கணக்கிட வரைபட முறையைப் பயன்படுத்துவோம்:

வர் எண்கள் = [1, 2, 3, 4, 5, 6]; செயல்பாடு சதுரம்(மதிப்பு, குறியீட்டு, வரிசை) (திரும்ப முடிவு = மதிப்பு * மதிப்பு; ); var squareArray = numbers.map(square); document.write(squareArray);

வரைபடம்() முறைக்கு அனுப்பப்படும் செயல்பாடு, தற்போதைய உறுப்பை மீண்டும் செயல்படுத்தி, அதன் மீது செயல்பாடுகளைச் செய்து சில மதிப்பை வழங்குகிறது. இந்த மதிப்பு அதன் விளைவாக வரும் சதுரவரிசைக்கு செல்கிறது

இந்தக் கட்டுரையில் எண் குறியீடுகளுடன் நிலையான ஜாவாஸ்கிரிப்ட் வரிசைகளைப் பார்ப்போம். சதுர அடைப்புக்குறிகளைப் பயன்படுத்தி வரிசைகள் அறிவிக்கப்படுகின்றன:

var பழங்கள் = ["ஆப்பிள்", "ஆரஞ்சு", "கழுதை"]

ஒரு உறுப்பைப் பிரித்தெடுக்க, அதன் குறியீட்டை சதுர அடைப்புக்குறிக்குள் வைக்கவும். முதல் அட்டவணை 0:

var பழங்கள் = ["ஆப்பிள்", "ஆரஞ்சு", "கழுதை"] எச்சரிக்கை(பழங்கள்) எச்சரிக்கை(பழங்கள்) எச்சரிக்கை(பழங்கள்)

ஜாவாஸ்கிரிப்ட் வரிசையின் நீளத்தையும் நாம் பெறலாம்:

var பழங்கள் = ["ஆப்பிள்", "ஆரஞ்சு", "கழுதை"] எச்சரிக்கை(fruits.length)

அச்சச்சோ! இரண்டு பழங்கள் மற்றும் ஒரு கழுதையுடன் ஒரு வரிசையை உருவாக்கினோம். இப்போது நாம் கழுதையை அகற்ற வேண்டும்.

பாப் மற்றும் புஷ் முறைகள்

ஜாவாஸ்கிரிப்டில் உள்ள பாப் முறையானது அணிவரிசையிலிருந்து ஒரு உறுப்பை அகற்றி, அதைத் திருப்பித் தருகிறது.

ஒரு அணிவரிசையிலிருந்து "கழுதை" எவ்வாறு மீட்டெடுக்கப்படுகிறது என்பதை பின்வரும் எடுத்துக்காட்டு காட்டுகிறது:

var பழங்கள் = ["ஆப்பிள்", "ஆரஞ்சு", "கழுதை"] எச்சரிக்கை("நான் "+fruits.pop()) // இப்போது எங்களிடம் உள்ளது ["ஆப்பிள்","ஆரஞ்சு"] எச்சரிக்கை("இப்போது வரிசையின் அளவு : "+fruits.length) // கழுதை அகற்றப்பட்டது

பாப் வரிசையையே மாற்றியமைக்கிறது என்பதை நினைவில் கொள்ளவும்.

Pop இன் இணையானது புஷ் முறை ஆகும், இது ஒரு அணிவரிசையில் ஒரு உறுப்பைச் சேர்க்கிறது. எடுத்துக்காட்டாக, ஒரு பீச் சேர்க்க மறந்துவிட்டோம்:

var பழங்கள் = ["ஆப்பிள்", "ஆரஞ்சு"] பழங்கள்.புஷ்("பீச்"); // இப்போது எங்களிடம் ["ஆப்பிள்", "ஆரஞ்சு", "பீச்"] எச்சரிக்கை ("கடைசி உறுப்பு:"+பழங்கள்)

1. கூறுகளுடன் கூடிய பாணிகளின் வரிசையை உருவாக்கவும் " ஜாஸ்”, “ப்ளூஸ்”;
2. மதிப்பைச் சேர்க்கவும்" ராக் அன் ரோல்«;
3. முடிவில் இருந்து இரண்டாவது மதிப்பை "மதிப்புடன் மாற்றவும். செந்தரம்". நீங்கள் ஒரு வரிசையுடன் முடிக்க வேண்டும்: " ஜாஸ்”, ”செந்தரம்”, ”ராக் அன் ரோல்" எந்த வரிசை நீளத்திற்கும் குறியீடு வேலை செய்ய வேண்டும்;
4. அணிவரிசையிலிருந்து கடைசி மதிப்பை மீட்டெடுத்து, அதை விழிப்பூட்டல் வழியாகக் காண்பிக்கவும்.

தீர்வு

// 1 var பாணிகள் = ["Jazz", "Bluez"] // 2 styles.push("Rock"n"Roll") // அல்லது: styles = "Rock"n"Roll" // 3 styles = "Classic " // 4 எச்சரிக்கை(styles.pop())

Shift/unshift முறைகள்

ஷிப்ட்/அன்ஷிஃப்ட் முறைகள் வரிசையின் முடிவில் வேலை செய்கின்றன, ஆனால் உறுப்புகளை மேலே மாற்றுவதற்கு ஷிஃப்டையும் பயன்படுத்தலாம் ( உறுப்புகளை மாற்றுவதன் மூலம் அணிவரிசையின் முதல் மதிப்பு அகற்றப்படும்) அன்ஷிஃப்ட் முறையானது ஜாவாஸ்கிரிப்டை முடிவில் இருந்து ஒரு வரிசைக்கு ஒரு உறுப்பை சேர்க்க அனுமதிக்கிறது:

var பழங்கள் = ["ஆப்பிள்", "ஆரஞ்சு"] var apple = fruits.shift() // இப்போது நம்மிடம் ["ஆரஞ்சு"] பழங்கள் மட்டுமே உள்ளன.unshift("எலுமிச்சை") // இப்போது நம்மிடம் ["எலுமிச்சை", " ஆரஞ்சு"] எச்சரிக்கை(fruits.length) // 2

ஷிஃப்ட் மற்றும் அன்ஷிஃப்ட் இரண்டும் ஒரே நேரத்தில் பல உறுப்புகளில் செயல்பட முடியும்:

var பழங்கள் = ["Apple"] fruits.push("Orange","Peach") fruits.unshift("அன்னாசி","எலுமிச்சை") // இப்போது வரிசை இப்படி உள்ளது: ["அன்னாசி", "எலுமிச்சை", "ஆப்பிள்" ", "ஆரஞ்சு", "பீச்"]

சுயநிர்வாகப் பணி

விழிப்பூட்டல் வழியாக அணிவரிசையில் இருந்து சீரற்ற மதிப்பைக் காட்ட குறியீட்டை எழுதவும்:

var arr = ["பிளம்","ஆரஞ்சு","கழுதை","கேரட்","ஜாவாஸ்கிரிப்ட்"]

குறிப்பு: ரேண்டம் எண்ணை குறைந்தபட்சத்திலிருந்து அதிகபட்ச மதிப்பு வரை (உள்ளடக்க) பெறுவதற்கான குறியீடு பின்வருமாறு:

var rand = நிமிடம் + Math.floor(Math.random()*(max+1-min))

தீர்வு

0 இலிருந்து arr.length-1 (உள்ளடக்கம்) வரையிலான ஒரு சீரற்ற எண்ணைப் பிரித்தெடுக்க வேண்டும்:

var arr = ["Plum","Orange","Donkey","Carrot","JavaScript"] var rand = Math.floor(Math.random()*arr.length) எச்சரிக்கை(arr)

ஒரு வரிசையின் மேல் திரும்ப திரும்ப

ஜாவாஸ்கிரிப்ட்டில், ஒரு வரிசை மூலம் மீண்டும் செய்வது ஒரு ஃபார் லூப்பைப் பயன்படுத்தி செய்யப்படுகிறது:

var பழங்கள் = ["அன்னாசி", "எலுமிச்சை", "ஆப்பிள்", "ஆரஞ்சு", "பீச்"] for(var i=0; i

சுயநிர்வாகப் பணி

கொடுக்கப்பட்ட அணிவரிசையில் ஒரு மதிப்பைக் கண்டறிந்து அதன் குறியீட்டை அல்லது மதிப்பு கிடைக்கவில்லை என்றால் -1 ஐ வழங்கும் செயல்பாட்டைக் கண்டுபிடி(arr,value) உருவாக்கவும்.

உதாரணத்திற்கு:

arr = [ "சோதனை", 2, 1.5, பொய் ] கண்டுபிடி(arr, "சோதனை") // 0 find(arr, 2) // 1 find(arr, 1.5) // 2 find(arr, 0) // -1

தீர்வு

சாத்தியமான தீர்வு இப்படி இருக்கலாம்:

செயல்பாடு கண்டுபிடிப்பு (வரிசை, மதிப்பு) ((var i=0; i

ஆனால் இது தவறானது, ஏனெனில் == 0 மற்றும் பொய்க்கு இடையிலான வேறுபாட்டை வரையறுக்கவில்லை.

ஜாவாஸ்கிரிப்ட்டில் அணிவரிசைகளுடன் பணிபுரியும் போது === பயன்படுத்துவது மிகவும் சரியானது. கூடுதலாக, சமீபத்திய ES5 தரநிலையில் Array#indexOf செயல்பாடு உள்ளது. இதன் மூலம், இது போன்ற ஒரு செயல்பாட்டை நாம் வரையறுக்கலாம்:

செயல்பாடு கண்டறிதல் (வரிசை, மதிப்பு) ((array.indexOf) array.indexOf(மதிப்பு) க்கு (var i=0; i) வழங்கினால்

IndexOf முறை உள்ளதா என்பதைச் சரிபார்க்க ஒரு நிபந்தனையுடன் கண்டுபிடிப்பை வரையறுப்பது இன்னும் புத்திசாலித்தனமாக இருக்கும்.

சுயநிர்வாகப் பணி

ஒரு வரிசையை எடுத்து, arr இலிருந்து எண் மதிப்புகளை மட்டுமே கொண்ட புதிய வரிசையை வழங்கும் வடிப்பான எண்(arr) செயல்பாட்டை உருவாக்கவும்.

இது எவ்வாறு செயல்பட வேண்டும் என்பதற்கான எடுத்துக்காட்டு:

arr = ["a", 1, "b", 2]; arr = filterNumeric(arr); // இப்போது arr =

தீர்வு

வரிசையின் மூலம் மீண்டும் மீண்டும் பெறுவதும், மதிப்புகள் எண்களாக இருந்தால் புதிய வரிசையில் சேர்ப்பதும் தீர்வு.

சேர மற்றும் பிரிக்க

சில நேரங்களில் ஜாவாஸ்கிரிப்ட் வரிசையை சரமாக மாற்ற விரைவான வழி தேவை. இதற்குத்தான் சேரும் முறை.

இது கொடுக்கப்பட்ட டிலிமிட்டரைப் பயன்படுத்தி வரிசையை ஒரு சரமாக இணைக்கிறது:

var பழங்கள் = ["எலுமிச்சை","ஆப்பிள்","ஆரஞ்சு","பீச்"]; var str = fruits.join(", "); எச்சரிக்கை(str);

பிளவு முறையைப் பயன்படுத்தி தலைகீழ் மாற்றம் எளிதாக செய்யப்படுகிறது:

var பழங்கள் = "ஆப்பிள், ஆரஞ்சு, பீச்"; var arr = fruits.split(","); // arr இப்போது ["ஆப்பிள்", "ஆரஞ்சு", "பீச்"] எச்சரிக்கை(arr);

சுயநிர்வாகப் பணி

பொருளில் className பண்பு உள்ளது, இதில் வகுப்புப் பெயர்கள் உள்ளன, இடைவெளிகளால் பிரிக்கப்படுகின்றன:

கிளாஸ் cls ஐ சேர்க்கும் addClass(obj, cls) செயல்பாட்டை எழுதவும், ஆனால் அது இல்லாவிட்டால் மட்டும்:

ddClass(obj, "new") // obj.className="திறந்த மெனு புதிய" addClass(obj, "open") // மாற்றங்கள் இல்லை (வகுப்பு ஏற்கனவே உள்ளது) addClass(obj, "me") // obj.className= "திறந்த மெனு புதிய என்னை" எச்சரிக்கை(obj.className) //

தீர்வு

நீங்கள் className மற்றும் loop ஐ பகுதிகளாக பிரிக்க வேண்டும். வகுப்பு கிடைக்கவில்லை என்றால், அது சேர்க்கப்படும்.

செயல்திறனை அதிகரிக்க லூப் சிறிது உகந்ததாக உள்ளது:

செயல்பாடு addClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) திரும்ப elem.className += " "+cls ) var obj = ( className: "open menu" ) addClass(obj, "new") addClass(obj, "open") alert(obj.className) // மெனுவைத் திறக்கவும் புதிய

மேலே உள்ள எடுத்துக்காட்டில், சுழற்சியின் தொடக்கத்தில் c மாறி வரையறுக்கப்படுகிறது மற்றும் அதன் கடைசி குறியீடு i க்கு அமைக்கப்பட்டுள்ளது.

லூப் தானே எதிர் திசையில் செயலாக்கப்படுகிறது, i>=0 நிபந்தனையுடன் முடிவடைகிறது. ஏனெனில் i>=0 ஐ விட வேகமாக சரிபார்க்கிறது. ஜாவாஸ்கிரிப்டில் உள்ளவை வரிசையில் தேடுவதை துரிதப்படுத்துகிறது.

வரிசையை ஒழுங்கமைக்க நீளத்தைப் பயன்படுத்துதல்

நீளப் பண்புகளைப் பயன்படுத்தி, இது போன்ற ஒரு வரிசையை நீங்கள் துண்டிக்கலாம்:

நீங்கள் நீளத்தைக் குறிப்பிடுகிறீர்கள் மற்றும் உலாவி வரிசையை துண்டிக்கிறது.

வரிசை என்பது ஒரு பொருள், இதன் பொருள் என்ன?

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

இது மற்ற மொழிகளில் உள்ள கருத்தாக்கத்திலிருந்து வேறுபட்டது, அங்கு வரிசைகள் நினைவகத்தின் தொடர்ச்சியான பகுதியைக் குறிக்கின்றன. இது இணைக்கப்பட்ட பட்டியல்களின் அடிப்படையில் வரிசை அல்லது அடுக்கில் இருந்து வேறுபட்டது.

எண் அல்லாத வரிசை விசைகள்

விசைகள் எண்கள், ஆனால் அவை எந்த பெயரையும் கொண்டிருக்கலாம்:

arr = arr = 5 arr.prop = 10 // இதைச் செய்ய வேண்டாம்

ஜாவாஸ்கிரிப்ட்டில், வரிசைகள் ஹாஷ் அட்டவணைகள் ஆகும், அவை செயல்திறன் நன்மைகள் ஆனால் சில தீமைகள் உள்ளன.

எடுத்துக்காட்டாக, புஷ்/பாப் ஒரு வரிசையின் வெளிப்புற உறுப்புகளில் மட்டுமே செயல்படும், எனவே அவை நம்பமுடியாத வேகமானவை.

புஷ் முடிவில் மட்டுமே வேலை செய்கிறது:

var arr = ["My", "array"] arr.push("something") alert(arr) // string "array"

ஷிப்ட்/அன்ஷிஃப்ட் முறைகள் மெதுவாக இருக்கும், ஏனெனில் அவை முழு வரிசையையும் மீண்டும் எண்ண வேண்டும். பிளவு முறையானது எண்ணை மாற்றுவதற்கும் காரணமாக இருக்கலாம்:

எனவே ஷிப்ட்/அன்ஷிஃப்ட் புஷ்/பாப்பை விட மெதுவாக இருக்கும். பெரிய வரிசை, வரிசையை வரிசைப்படுத்த ஜாவாஸ்கிரிப்ட் அதிக நேரம் எடுக்கும்.

சுயநிர்வாகப் பணி

விளைவு என்னவாக இருக்கும்? ஏன்?

arr = ["a", "b"] arr.push(function() ( alert(இது) ) arr() // ?

தீர்வு

வரிசைகள் பொருள்கள் என்பதால், arr ..உண்மையில் obj போன்ற ஒரு பொருளின் முறை அழைப்பு முறை:

arr() // arr() // வாக்கியரீதியாக தவறானது, ஆனால் கருத்துரீதியாக அதே: arr.2() // obj.method() போன்ற அதே பாணியில் மீண்டும் எழுதப்பட்டது இந்த = arr செயல்பாட்டிற்கு அனுப்பப்பட்டது, எனவே arr இன் உள்ளடக்கங்கள் அச்சிடப்படுகின்றன. arr = ["a", "b"] arr.push(function() ( alert(this) )) arr() // "a","b",function

அரிதான வரிசைகள், நீள விளக்கம்

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

பின்வரும் எடுத்துக்காட்டில், காலியான பழங்களில் இரண்டு கூறுகளைச் சேர்ப்போம், ஆனால் நீள மதிப்பு 100 ஆக இருக்கும்:

var பழங்கள் = // வெற்று வரிசை பழங்கள் = "பீச்" பழங்கள் = "ஆப்பிள்" எச்சரிக்கை(fruits.length) // 100 (ஆனால் வரிசையில் 2 கூறுகள் மட்டுமே உள்ளன)

நீங்கள் ஒரு அரிதான வரிசையை வெளியிட முயற்சித்தால், உலாவி காணாமல் போன குறியீட்டு மதிப்புகளை வெற்று உறுப்புகளாக வழங்கும்:

var பழங்கள் = // வெற்று வரிசை பழங்கள் = "பீச்" பழங்கள் = "ஆப்பிள்" எச்சரிக்கை(பழங்கள்) // ,பீச், ஆப்பிள் (அல்லது அது போன்ற ஏதாவது)

ஆனால் வரிசை என்பது இரண்டு விசைகளைக் கொண்ட ஒரு பொருள். விடுபட்ட மதிப்புகள் இடத்தை எடுத்துக்கொள்ளாது.

வரிசை முறைகள் பயன்படுத்தப்படும் போது, ​​அரிதான வரிசைகள் வித்தியாசமாக நடந்து கொள்கின்றன. குறியீடுகள் காணவில்லை என்பது அவர்களுக்குத் தெரியாது:

var பழங்கள் = பழங்கள் = "பீச்" பழங்கள் = "ஆப்பிள்" எச்சரிக்கை(fruits.pop()) // பாப் "ஆப்பிள்" (இன்டெக்ஸ் 9 க்கு) எச்சரிக்கை(fruits.pop()) // குறிப்பிடப்படாத உறுப்பை (இன்டெக்ஸ் 8க்கு) பாப் செய்யவும் )

அரிதான வரிசைகளைத் தவிர்க்க முயற்சிக்கவும். எந்தவொரு சந்தர்ப்பத்திலும், அவர்களின் முறைகள் சாதாரணமாக வேலை செய்யாது. அதற்குப் பதிலாக பொருளைப் பயன்படுத்தவும்.

வரிசையிலிருந்து நீக்குதல்

நமக்குத் தெரியும், வரிசைகள் பொருள்கள், எனவே மதிப்பை அகற்ற நீக்கத்தைப் பயன்படுத்தலாம்:

var arr = ["Go", "to", "home"] dele arr // now arr = ["Go", undefined, "home"] alert(arr) // வரையறுக்கப்படவில்லை

மதிப்பு அகற்றப்பட்டதை நீங்கள் காணலாம், ஆனால் நாங்கள் விரும்பும் வழியில் இல்லை, ஏனெனில் அணிவரிசையில் குறிப்பிடப்படாத உறுப்பு உள்ளது.

நீக்கு ஆபரேட்டர் ஒரு முக்கிய மதிப்பு ஜோடியை நீக்குகிறது, அவ்வளவுதான். இயற்கையாகவே, வரிசை ஒரு ஹாஷ் மட்டுமே என்பதால், அகற்றப்பட்ட உறுப்பின் நிலை வரையறுக்கப்படவில்லை.

பெரும்பாலும் நாம் குறியீடுகளுக்கு இடையில் "துளைகளை" விட்டுவிடாமல் ஒரு உறுப்பை அகற்ற வேண்டும். இதற்கு நமக்கு உதவும் மற்றொரு முறை உள்ளது.

பிளவு முறை

ஸ்ப்லைஸ் முறையானது உறுப்புகளை அகற்றி அவற்றை ஜாவாஸ்கிரிப்ட் பல பரிமாண வரிசைகளில் மாற்றும். அதன் தொடரியல்:

arr.splice(index, deleteCount[, elem1, ..., elemN])

குறியீட்டில் தொடங்கும் deleteCount உறுப்பை நீக்கி, அதன் இடத்தில் elem1, ..., elemN ஐச் செருகும்.

சில உதாரணங்களைப் பார்ப்போம்:

var arr = ["Go", "to", "home"] arr.splice(1, 1) // index 1 alert(arr.join(",")) // ["Go " , "வீடு"] (1 உறுப்பு அகற்றப்பட்டது)

எனவே நீங்கள் ஒரு வரிசையிலிருந்து ஒரு உறுப்பை அகற்ற ஸ்பைஸைப் பயன்படுத்தலாம். இடத்தை நிரப்ப வரிசை உறுப்பு எண்கள் மாற்றப்படுகின்றன:

var arr = ["Go", "to", "home"] arr.splice(0, 1) // 1 உறுப்பை அகற்று, குறியீட்டு 0 எச்சரிக்கை(arr) இலிருந்து தொடங்கி // "to" முதல் உறுப்பு ஆனது

பின்வரும் எடுத்துக்காட்டு கூறுகளை எவ்வாறு மாற்றுவது என்பதைக் காட்டுகிறது:

ஸ்பைஸ் முறை அகற்றப்பட்ட உறுப்புகளின் வரிசையை வழங்குகிறது:

var arr = ["செல்", "க்கு", "வீடு", "இப்போது"]; // முதல் 2 உறுப்புகளை அகற்று var அகற்றப்பட்டது = arr.splice(0, 2) எச்சரிக்கை(அகற்றப்பட்டது) // "Go", "to"<-- массив удаленных элементов splice может вставлять элементы, задайте 0 для deleteCount. var arr = ["Go", "to", "home"]; // со второй позиции // удаляем 0 // и вставляем "my", "sweet" arr.splice(2, 0, "my", "sweet") alert(arr) // "Go", "to", "my", "sweet", "home"

இந்த முறை எதிர்மறை குறியீட்டையும் பயன்படுத்தலாம், இது வரிசையின் முடிவில் இருந்து கணக்கிடப்படுகிறது:

var arr = // உறுப்பு -1 (இறுதி) // 0 உறுப்புகளை அகற்றவும், // மற்றும் 3 மற்றும் 4 arr.splice(-1, 0, 3, 4) எச்சரிக்கை(arr) // 1,2,3, 4.5

சுயநிர்வாகப் பணி

பொருளில் className பண்பு உள்ளது, இதில் வகுப்புப் பெயர்கள் உள்ளன, இடைவெளிகளால் பிரிக்கப்படுகின்றன:

var obj = (வகுப்பு பெயர்: "திறந்த மெனு")

ரிமூவ் கிளாஸ்(obj, cls) செயல்பாட்டை எழுதவும், அது கொடுக்கப்பட்டால் கிளாஸ் cls ஐ நீக்குகிறது:

removeClass(obj, "open") // obj.className="menu" removeClass(obj, "blabla") // மாற்றங்கள் இல்லை (அகற்றுவதற்கு வகுப்பு இல்லை)

தீர்வு

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

இதை கொஞ்சம் மேம்படுத்துவோம்:

செயல்பாடு removeClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) c.splice(i,1) ) elem.className = c.join(" ") ) var obj = ( className: "open menu" ) removeClass(obj, "open") removeClass(obj, "blabla") எச்சரிக்கை (obj.className) // மெனு

மேலே உள்ள எடுத்துக்காட்டில், c மாறி லூப்பின் தொடக்கத்தில் அமைக்கப்பட்டுள்ளது மற்றும் i அதன் கடைசி குறியீட்டுக்கு அமைக்கப்பட்டுள்ளது.

லூப் தானே எதிர் திசையில் இயங்குகிறது, i>=0 என்ற நிபந்தனையுடன் முடிவடைகிறது. i>=0 ஐ விட வேகமாக சரிபார்க்கப்படுவதால் இது செய்யப்படுகிறது. இது c இல் உள்ள பண்புகளைத் தேடுவதை விரைவுபடுத்துகிறது.

துண்டு முறை

ஸ்லைஸ்(தொடங்கு[, முடிவு]) முறையைப் பயன்படுத்தி ஒரு வரிசையின் ஒரு பகுதியை நீங்கள் பிரித்தெடுக்கலாம்: var arr = ["ஏன்", "கற்று", "ஜாவாஸ்கிரிப்ட்"]; var arr2 = arr.slice(0,2) // 0 விழிப்பூட்டலில் தொடங்கி 2 கூறுகளை எடுக்கும்(arr2.join(", ")) // "ஏன், கற்க"

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

ஒரு குறிப்பிட்ட குறியீட்டில் தொடங்கும் அனைத்து கூறுகளையும் பெற இரண்டாவது வாதத்தை நீங்கள் தவிர்க்கலாம்:

var arr = ["ஏன்", "கற்க", "ஜாவாஸ்கிரிப்ட்"]; var arr2 = arr.slice(1) // 1 எச்சரிக்கை (arr2.join(", ")) // "கற்று, JavaScript" இலிருந்து தொடங்கும் அனைத்து கூறுகளையும் எடுக்கும்

இந்த முறை, String#slice போன்ற எதிர்மறை குறியீடுகளை ஆதரிக்கிறது.

தலைகீழ் முறை

மற்றொரு பயனுள்ள முறை தலைகீழ் ஆகும். "" போன்ற டொமைனின் கடைசிப் பகுதியைப் பெற விரும்புகிறேன் என்று வைத்துக் கொள்வோம். com"இருந்து" my.site.com" அதை எப்படி செய்வது என்பது இங்கே:

var டொமைன் = "my.site.com" var last = domain.split(".").reverse() alert(last)

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

ரிவர்ஸ்() போன்ற நீண்ட அழைப்புகளை உருவாக்கலாம் 0] arr.sort() alert(arr) // 1, 15, 2

மேலே உள்ள குறியீட்டை இயக்கவும். நீங்கள் ஆர்டர் 1, 15, 2 பெறுவீர்கள். ஏனென்றால், இந்த முறை எல்லாவற்றையும் சரமாக மாற்றுகிறது மற்றும் முன்னிருப்பாக லெக்சிகோகிராஃபிக் வரிசையைப் பயன்படுத்துகிறது.