அடுக்குகள் என்பது LIFO கொள்கையைப் பின்பற்றும் நேரியல் தரவு கட்டமைப்புகள். LIFO என்பது ஃபர்ஸ்ட் அவுட்டில் கடைசியாக உள்ளது, அதாவது சமீபத்தில் சேர்க்கப்பட்ட உருப்படி முதலில் அகற்றப்படும். இந்த தரவு கட்டமைப்பானது நிஜ உலக அடுக்குகளுக்கு ஒப்புமையாக ஸ்டாக் என பெயரிடப்பட்டது. எ.கா., குக்கீ ஜாரில் குக்கீகளின் அடுக்கு அல்லது புத்தக அலமாரியில் உள்ள புத்தகங்களின் அடுக்கு. அடுக்கில் செருகுதல் மற்றும் பிரித்தெடுத்தல் ஒரு முனையில் மட்டுமே செய்ய முடியும், அதாவது, அடுக்கின் மேல். உதாரணமாக, நாம் ஒரு குக்கீயை சாப்பிட விரும்பினால், முதலில் முதலிடம் பெறுவோம், பின்னர் 2வது மற்றும் பலவற்றைப் பெறுவோம்.
இந்த இடுகை ஜாவாஸ்கிரிப்டில் அடுக்கை செயல்படுத்துவது பற்றியதாக இருக்கும். நாங்கள் ஜாவாஸ்கிரிப்ட் உடன் பணிபுரிவதால், ஜாவாஸ்கிரிப்ட் பொருள்களின் அளவு மாறும் வகையில் வளரும் என்பதால், அடுக்கின் அளவைப் பற்றி நாங்கள் கவலைப்பட மாட்டோம்.
ஜாவாஸ்கிரிப்டில் ஸ்டாக்கை செயல்படுத்துதல்
ஸ்டேக் தரவு கட்டமைப்பை செயல்படுத்த ஜாவாஸ்கிரிப்ட் வகுப்பைப் பயன்படுத்துவோம். தி அடுக்கு கிளாஸ் அதன் கன்ஸ்ட்ரக்டரில் ஒரு வரிசையைக் கொண்டிருக்கும், இது அடுக்கில் உள்ள கூறுகளைச் சேமிக்கப் பயன்படும். அடுக்கின் உள்ளே சேமிக்கப்பட்ட தரவைக் கையாளப் பயன்படுத்தப்படும் வெவ்வேறு முறைகளையும் வகுப்பு வரையறுக்கும். வரிசையின் மிக அடிப்படையான முறைகள் செருகு() மற்றும் பிரித்தெடுத்தல் () அடுக்கின் மேற்புறத்தில் உள்ள கூறுகளைச் சேர்க்க மற்றும் அகற்றப் பயன்படுத்தப்படும் முறைகள்.
தி அடுக்கு வர்க்கம் போன்ற மற்ற முறைகளை வரையறுக்கிறது எட்டி() , காலியாக உள்ளது() , தெளிவான () , அச்சு () மற்றும் அளவு () அத்துடன்:
வகுப்பு அடுக்கு {
கட்டமைப்பாளர் ( ) {
இந்த. உறுப்புகள் = [ ] ;
}
// அடுக்கின் மேல் ஒரு பொருளை வைக்கிறது
செருகு ( உறுப்பு ) {
இந்த.உறுப்புகள்.தள்ளு ( உறுப்பு ) ;
}
// அடுக்கின் மேலிருந்து ஒரு பொருளை அகற்றும்
சாறு ( ) {
இந்த.உறுப்புகள்.பாப் ( ) ;
}
// அடுக்கின் மேல் உள்ள உறுப்பை வழங்கும்
எட்டிப்பார்க்க ( ) {
திரும்ப இந்த.உறுப்புகள் [ இந்த.உறுப்புகள்.நீளம் - 1 ] ;
}
// காசோலைகள் என்றால் அடுக்கு காலியாக உள்ளது
காலியாக உள்ளது ( ) {
திரும்ப this.elements.length == 0 ;
}
// முழு அடுக்கையும் அச்சிடுகிறது
அச்சு ( ) {
க்கான ( அனுமதிக்க நான் = 0 ; நான் < இந்த.உறுப்புகள்.நீளம்; நான்++ ) {
console.log ( இந்த.உறுப்புகள் [ நான் ] ) ;
}
}
// திரும்புகிறது அளவு அடுக்கின்
அளவு ( ) {
திரும்ப இந்த.உறுப்புகள்.நீளம்;
}
// அடுக்கை அழிக்கிறது
தெளிவானது ( ) {
இந்த. உறுப்புகள் = [ ] ;
}
}
அடுக்கிலிருந்து உறுப்புகளைத் தள்ளுதல் மற்றும் உறுத்தல்
அடுக்கின் மிக அடிப்படையான செயல்பாடானது அடுக்கின் மேற்பகுதியில் இருந்து உறுப்புகளைச் செருகுவதும் பிரித்தெடுப்பதும் ஆகும். ஸ்டாக் கிளாஸ் இந்த செயல்பாடுகளுக்கு இரண்டு முறைகளை வழங்குகிறது:
மேலே குறிப்பிடப்பட்ட குறியீட்டின் முதல் வரி, பெயரிடப்பட்ட புதிய அடுக்கை அறிவிக்கிறது கள் . பின்னர் தி செருகு() அடுக்கில் நான்கு கூறுகளைச் செருக முறை பயன்படுத்தப்படுகிறது, அவற்றில் இரண்டு பின்னர் அகற்றப்படும் பிரித்தெடுத்தல் () முறை.
அடுக்கில் இருந்து மேல் உறுப்பை எவ்வாறு பெறுவது
தி அடுக்கு வர்க்கம் வரையறுக்கிறது எட்டி() அடுக்கிலிருந்து மேல் உறுப்பைப் பெறுவதற்கான முறை:
ஸ்டாக் காலியாக உள்ளதா என்பதை எவ்வாறு சரிபார்க்கலாம்?
ஸ்டாக் காலியாக உள்ளதா என்பதைச் சரிபார்க்க பயன்படுத்தக்கூடிய ஒரு முறையை வகுப்பும் வரையறுக்கிறது:
முழு அடுக்கையும் அச்சிடுவது எப்படி?
தி அச்சு () முழு அடுக்கையும் அச்சிடுவதற்கான முறையை அழைக்கலாம்
அடுக்கின் அளவை எவ்வாறு சரிபார்க்கலாம்?
தி அளவு () முறை பயன்படுத்துகிறது .நீளம் அடுக்கின் அளவைப் பெறுவதற்கான சொத்து:
முழு அடுக்கையும் எப்படி அழிப்பது?
வெறுமனே அழைக்கவும் தெளிவான () அடுக்கின் ஒவ்வொரு உறுப்புகளையும் அகற்றும் முறை:
முடிவுரை
அடுக்குகள் என்பது உலாவி வரலாறு, உரை எடிட்டர்களில் உள்ள செயல்தவிர் பொத்தான் மற்றும் அழைப்பு பதிவுகள் போன்ற பல நிஜ உலக பயன்பாடுகளுடன் பயனுள்ள தரவு கட்டமைப்புகள் ஆகும். இந்தப் பயன்பாடுகள் அனைத்தும் LIFO கொள்கையைப் பின்பற்றுகின்றன. எ.கா., உலாவியில் உள்ள பின் பொத்தான் கடைசியாகப் பார்வையிட்ட பக்கத்திற்குத் திரும்பும் மற்றும் அழைப்புப் பதிவின் முதல் நுழைவு எப்போதும் சமீபத்திய அழைப்பாக இருக்கும்.
ஜாவாஸ்கிரிப்ட்டில் ஸ்டேக்கை செயல்படுத்துவது மிகவும் எளிதானது, ஏனெனில் அது உள்ளமைந்துள்ளது தள்ளு மற்றும் பாப் வரிசைகளுக்கான முறைகள். இந்தக் கட்டுரை ஜாவாஸ்கிரிப்டில் அடுக்கை செயல்படுத்தும் செயல்முறையை விளக்குகிறது.