[டெவலப்பர்கள் இரண்டு சரங்களை ஒப்பிட வேண்டிய சில சூழ்நிலைகள் உள்ளன. பெரும்பாலான புரோகிராமர்கள் == ஆபரேட்டரைப் பயன்படுத்தி ஜாவாஸ்கிரிப்டில் தங்கள் சரங்களை ஒப்பிட்டுப் பார்க்கும் முயற்சியில் அடிக்கடி தவறு செய்கிறார்கள். இந்த சூழ்நிலையில் == ஆபரேட்டருக்கு சில கட்டுப்பாடுகள் உள்ளன, ஏனெனில் மாறி வகைகளைப் பயன்படுத்தி அதைச் சரிபார்க்க முடியாது. எனவே, நிலைமையைக் கையாள வேறு வழிகளைத் தேட வேண்டியிருக்கலாம்.
இந்த கட்டுரை ஜாவாஸ்கிரிப்டில் சரங்களை ஒப்பிடுவதற்கான செயல்முறையை நிரூபிக்கும்.
ஜாவாஸ்கிரிப்டில் இரண்டு சரங்களை எவ்வாறு ஒப்பிடுவது?
இரண்டு ஜாவாஸ்கிரிப்ட் சரங்களை ஒப்பிட, பின்வரும் பட்டியலிடப்பட்ட முறைகளைப் பயன்படுத்தவும்:
- கடுமையான சமத்துவ ஆபரேட்டர் “===”
- localecompare() முறை
- சோதனை() முறையுடன் RegEx
- () முறையை உள்ளடக்கியது
ஒவ்வொரு முறையின் செயல்பாட்டையும் தனித்தனியாக ஆராய்வோம்.
முறை 1: கண்டிப்பான சமத்துவ ஆபரேட்டரைப் பயன்படுத்தி இரண்டு சரங்களை ஒப்பிடுக
சரங்கள் சமமாக உள்ளதா இல்லையா என்பதை சரிபார்க்க கடுமையான சமத்துவ ஆபரேட்டர் (===) பயன்படுத்தப்படலாம். சரங்கள் வேறுபட்டால், அது ஒரு வெளியீட்டாக தவறானதாகத் திரும்பும்; இல்லையெனில், அது உண்மையாக இருக்கும். இது ஒரு கேஸ்-சென்சிட்டிவ் முறையாக இருப்பதால், சரங்களை ஒப்பிடும் போது, இது எழுத்துக்களின் வழக்கையும் ஒப்பிடுகிறது, அதாவது சிறிய மற்றும் பெரிய எழுத்துக்கள் வேறுபட்டதாகக் கருதப்படுகின்றன.
தொடரியல்
கடுமையான சமத்துவ ஆபரேட்டரைப் பயன்படுத்தி இரண்டு சரங்களை ஒப்பிடுவதற்கு கீழே உள்ள தொடரியல் பயன்படுத்தவும்:
str1 === str2 ;இங்கே, ' === ” ஆபரேட்டர் str1 மற்றும் str2 இன் மதிப்பு மற்றும் தரவு வகையை ஒப்பிடுவார்.
உதாரணமாக
இந்த எடுத்துக்காட்டில், இரண்டு சரங்களை ஒன்று பெரிய எழுத்திலும் மற்றொன்று சிறிய எழுத்திலும் ஒப்பிடுவோம். அவ்வாறு செய்ய, முதலில், பெயரிடப்பட்ட இரண்டு மாறிகளை உருவாக்குவோம் 'str1' மற்றும் 'str2' அது சரங்களை சேமிக்கிறது ' LinuxHint 'மற்றும்' linuxhint ”:
இருந்தது str1 = 'LinuxHint' ;இருந்தது str2 = 'லினக்ஸ்' ;
பின்னர், அழைக்கவும் ' console.log() 'சரங்கள் சமமாக உள்ளதா அல்லது பயன்படுத்தவில்லையா என்பதைச் சொல்லும் முடிவை அச்சிடுவதற்கான முறை' === 'ஆபரேட்டர்:
பணியகம். பதிவு ( str1 === str2 ) ;வெளியீடு காட்டுகிறது ' பொய் ” இது சமத்துவ ஆபரேட்டர் கேஸ்-சென்சிட்டிவ் ஒப்பீட்டைச் செய்வதால் சரங்கள் சமமாக இல்லை என்பதைக் குறிக்கிறது:
சரங்களுக்கு இடையே கேஸ்-சென்சிட்டிவ் ஒப்பீட்டை நீங்கள் செய்ய விரும்பினால், கீழே கொடுக்கப்பட்டுள்ள முறைகளைப் பின்பற்ற வேண்டும்.
முறை 2: localecompare() முறையைப் பயன்படுத்தி இரண்டு சரங்களை ஒப்பிடுக
' உள்ளூர் ஒப்பிடு() ” என்பது ஜாவாஸ்கிரிப்ட் முன் வரையறுக்கப்பட்ட முறையாக இரண்டு சரங்களை ஒப்பிட பயன்படுகிறது. இது கேஸ்-சென்சிட்டிவ் சரம் ஒப்பீட்டைச் செய்கிறது மற்றும் இரண்டு சரங்களை ஒப்பிடுவதற்கு தற்போதைய இடத்தைப் பயன்படுத்துகிறது.
தொடரியல்
LocalCompare() முறையைப் பயன்படுத்தி இரண்டு சரங்களை ஒப்பிடுவதற்கு கீழே குறிப்பிடப்பட்டுள்ள தொடரியல் பின்பற்றவும்:
str1. உள்ளூர் ஒப்பிடு ( str2 ) ;இங்கே,' str2 ' என்பதுடன் ஒப்பிடப்படும் சரம் ' str1 ”:
உதாரணமாக
முந்தைய எடுத்துக்காட்டில் ஏற்கனவே உருவாக்கப்பட்ட அதே சரங்களை இப்போது பயன்படுத்துவோம், பின்னர் அவற்றைப் பயன்படுத்தி ஒப்பிடுவோம். உள்ளூர் ஒப்பிடு() நிபந்தனை ஆபரேட்டரின் உதவியுடன் 'முறை:
என்றால் ( str1. உள்ளூர் ஒப்பிடு ( str2 ) ) {பணியகம். பதிவு ( 'str1 என்பது str2 க்கு சமம்' ) ;
} வேறு {
பணியகம். பதிவு ( 'str1 என்பது str2 க்கு சமம் இல்லை' ) ;
}
இந்த முறையானது கேஸ்-உணர்வற்ற ஒப்பீட்டை ஒப்பிடுவதால், வெளியீடு சரங்கள் சமமாக இருப்பதை நீங்கள் பார்க்க முடியும்:
அடுத்த முறைக்கு செல்வோம்!
முறை 3: RegExp ஐப் பயன்படுத்தி இரண்டு சரங்களை டெஸ்ட்() முறையுடன் ஒப்பிடுக
இரண்டு சரங்களை ஒப்பிடுவதற்கு மற்றொரு முறை உள்ளது, இது கேஸ்-சென்சிட்டிவ் ஒப்பீட்டையும் செய்கிறது ' RegExp '' உதவியுடன் சோதனை () ”முறை. இது வரையறுக்கப்பட்ட ரீஜெக்ஸின் அடிப்படையில் சரங்களின் சமத்துவத்தை சரிபார்க்கிறது. சோதனை() முறை ஒரு சரத்தை ஒப்பிடுவதற்கான வாதமாக ஏற்றுக்கொள்ளும்.
தொடரியல்
சோதனை() முறையுடன் RegEx ஐப் பயன்படுத்தி test() முறைக்கு கொடுக்கப்பட்ட தொடரியல் பின்பற்றவும்:
regPattern. சோதனை ( str2 ) ;இங்கே,' str2 ' என்பதுடன் ஒப்பிடப்படும் சரம் ' regPattern ”:
உதாரணமாக
இப்போது, ஒரு சரத்தை அனுப்புவதன் மூலம் RegExp இன் நிகழ்வை உருவாக்குவோம். str1 'மற்றும் ஒரு ரீஜெக்ஸ்' ஜி.ஐ 'இது கேஸ்-உணர்வற்ற ஒப்பீட்டைக் குறிக்கிறது மற்றும் அதை ஒரு மாறியில் சேமிக்கிறது' regPattern ”:
இருந்தது regPattern = புதிய RegExp ( str1 , 'ஜி' ) ;அதன் பிறகு, நாங்கள் அழைப்போம் ' சோதனை () 'சரத்தை கடந்து செல்லும் முறை' str2 ” ஒரு வாதமாக.
இருந்தது ஆண்டு = regPattern. சோதனை ( str2 ) ;பின்னர், சரங்கள் சமமாக உள்ளதா இல்லையா என்பதை சரிபார்க்க நிபந்தனை அறிக்கையைப் பயன்படுத்தவும்:
என்றால் ( ஆண்டு ) {பணியகம். பதிவு ( 'str1 என்பது str2 க்கு சமம்' ) ;
} வேறு {
பணியகம். பதிவு ( 'str1 என்பது str2 க்கு சமம் இல்லை' ) ;
}
வெளியீடு
நீங்கள் ஒரு சரத்தை மற்றொரு சரத்துடன் துணை சரமாக ஒப்பிட விரும்பினால், கீழே உள்ள பகுதியை நீங்கள் பின்பற்ற வேண்டும்.
முறை 4: அடங்கும்() முறையைப் பயன்படுத்தி இரண்டு சரங்களை ஒப்பிடுக
சரம் மற்ற சரத்தின் துணை சரமா என்பதை தீர்மானிக்க, ஜாவாஸ்கிரிப்ட் ஒரு முன் வரையறுக்கப்பட்ட முறையை வழங்குகிறது ' அடங்கும் () ”முறை. இது ஒரு சரத்தை ஒரு வாதமாக எடுத்து பூலியன் மதிப்பை அளிக்கிறது ' உண்மை ” அது சரத்தில் இருந்தால்; இல்லையெனில், அது திரும்பும்' பொய் ”.
தொடரியல்
அடங்கும் () முறையைப் பயன்படுத்துவதற்கு கீழே கொடுக்கப்பட்டுள்ள முறையைப் பின்பற்றவும்:
str1. அடங்கும் ( str2 ) ;இங்கே,' str2 ” என்பது சரம் சேர்க்கப்பட்டுள்ளதா அல்லது அதன் ஒரு பகுதியா என்பதைச் சரிபார்க்கும் str1 ”:
உதாரணமாக
இங்கே, முதலில், நாம் இரண்டு சரங்களை உருவாக்குவோம், 'str1' மற்றும் 'str2' இரண்டாவது சரம் முதல் சரமா இல்லையா என்பதைச் சரிபார்க்கவும்:
இருந்தது str1 = 'LinuxHint' ;இருந்தது str2 = 'உள்' ;
இதற்காக, அழைக்கவும் 'str2' ஐக் கடந்து 'உள்ளடக்கம்()' முறை ஒரு வாதமாக:
பணியகம். பதிவு ( str1. அடங்கும் ( str2 ) ) ;வெளியீடு கொடுக்கிறது ' உண்மை 'இது குறிக்கிறது' str2 ' என்பது ' str1 ”:
இரண்டு ஜாவாஸ்கிரிப்ட் சரங்களை ஒப்பிடுவதற்கான அனைத்து முறைகளையும் தொகுத்துள்ளோம்.
முடிவுரை
இரண்டு ஜாவாஸ்கிரிப்ட் சரங்களை ஒப்பிட்டுப் பார்க்க, நீங்கள் localCompare() முறை, கண்டிப்பான சமத்துவ ஆபரேட்டர், RegEx உடன் test() முறை அல்லது அடங்கும்() முறையைப் பயன்படுத்தலாம். கண்டிப்பான சமத்துவ ஆபரேட்டர் ஒரு கேஸ்-சென்சிட்டிவ் ஒப்பீட்டைச் செய்கிறார், அதே நேரத்தில் சோதனை() முறை மற்றும் லோகேம்பேர் () முறை ஆகியவை கேஸ்-உணர்வற்ற ஒப்பீட்டைச் செய்கின்றன. கடைசியாக, அடங்கும்() முறையானது சரத்தை மற்றொரு சரத்தில் துணை சரமாக சரிபார்க்கிறது. இந்த கட்டுரையில், ஜாவாஸ்கிரிப்டில் உள்ள இரண்டு சரங்களை சரியான எடுத்துக்காட்டுகளுடன் ஒப்பிடுவதற்கான முறைகளை நாங்கள் விளக்கினோம்.