[డెవలపర్‌లు రెండు స్ట్రింగ్‌లను సరిపోల్చాల్సిన కొన్ని పరిస్థితులు ఉన్నాయి. చాలా మంది ప్రోగ్రామర్లు తరచుగా == ఆపరేటర్‌ని ఉపయోగించి జావాస్క్రిప్ట్‌లో తమ స్ట్రింగ్‌లను పోల్చడానికి ప్రయత్నించడంలో పొరపాటు చేస్తారు. ఈ పరిస్థితిలో == ఆపరేటర్‌కు కొన్ని పరిమితులు ఉన్నాయి, ఎందుకంటే వేరియబుల్ రకాలు దీనిని ఉపయోగించి ధృవీకరించబడవు. కాబట్టి, మీరు పరిస్థితిని నిర్వహించడానికి ఇతర పద్ధతుల కోసం వెతకాలి.
ఈ కథనం జావాస్క్రిప్ట్‌లో స్ట్రింగ్‌లను పోల్చే విధానాన్ని ప్రదర్శిస్తుంది.
జావాస్క్రిప్ట్‌లో రెండు స్ట్రింగ్‌లను ఎలా పోల్చాలి?
రెండు జావాస్క్రిప్ట్ స్ట్రింగ్‌లను పోల్చడానికి, కింది జాబితా చేయబడిన పద్ధతులను ఉపయోగించండి:
- కఠినమైన సమానత్వ ఆపరేటర్ “===”
- localeCompare() పద్ధతి
- పరీక్ష() పద్ధతితో RegEx
- () పద్ధతిని కలిగి ఉంటుంది
ప్రతి పద్ధతి యొక్క పనిని విడిగా పరిశీలిద్దాం.
విధానం 1: కఠినమైన సమానత్వ ఆపరేటర్‌ని ఉపయోగించి రెండు స్ట్రింగ్‌లను సరిపోల్చండి
స్ట్రింగ్‌లు సమానంగా ఉన్నాయా లేదా అని ధృవీకరించడానికి కఠినమైన సమానత్వ ఆపరేటర్ (===) ఉపయోగించవచ్చు. స్ట్రింగ్‌లు భిన్నంగా ఉంటే, అది అవుట్‌పుట్‌గా తప్పుగా తిరిగి వస్తుంది; లేకపోతే, అది నిజం చేస్తుంది. ఇది కేస్-సెన్సిటివ్ పద్ధతి కాబట్టి, స్ట్రింగ్‌లను పోల్చేటప్పుడు, ఇది అక్షరాల కేసును కూడా పోలుస్తుంది, అంటే చిన్న అక్షరాలు మరియు పెద్ద అక్షరాలు వేర్వేరుగా పరిగణించబడతాయి.
వాక్యనిర్మాణం
స్ట్రిక్ట్ ఈక్వాలిటీ ఆపరేటర్‌ని ఉపయోగించి రెండు స్ట్రింగ్‌లను సరిపోల్చడానికి క్రింది వాక్యనిర్మాణాన్ని ఉపయోగించండి:
str1 === str2 ;ఇక్కడ, ' === ” ఆపరేటర్ str1 మరియు str2 యొక్క విలువ మరియు డేటాటైప్‌ను పోల్చి చూస్తారు.
ఉదాహరణ
ఈ ఉదాహరణలో, మేము రెండు తీగలను ఒకటి పెద్ద అక్షరంలో మరియు మరొకటి చిన్న అక్షరాలతో పోల్చి చూస్తాము. అలా చేయడానికి, మొదట, మేము పేరుతో రెండు వేరియబుల్స్ సృష్టిస్తాము “str1” మరియు “str2” అది తీగలను నిల్వ చేస్తుంది' LinuxHint 'మరియు' linuxhint ”:
ఉంది str1 = 'LinuxHint' ;ఉంది str2 = 'linux' ;
అప్పుడు, కాల్ చేయండి ' console.log() 'తీగలు సమానంగా ఉన్నాయా లేదా ఉపయోగించలేదా' అనే ఫలితాన్ని ముద్రించే పద్ధతి === 'ఆపరేటర్:
కన్సోల్. లాగ్ ( str1 === str2 ) ;అవుట్పుట్ చూపిస్తుంది ' తప్పుడు ” సమానత్వ ఆపరేటర్ కేస్-సెన్సిటివ్ పోలికను నిర్వహిస్తుంది కాబట్టి స్ట్రింగ్‌లు సమానంగా లేవని సూచిస్తుంది:
మీరు స్ట్రింగ్‌ల మధ్య కేస్-సెన్సిటివ్ పోలికను చేయాలనుకుంటే, మీరు క్రింద ఇవ్వబడిన పద్ధతులను అనుసరించాలి.
విధానం 2: లొకేల్‌ని ఉపయోగించి రెండు తీగలను సరిపోల్చండి () పద్ధతి
' లొకేల్ సరిపోల్చండి() ” అనేది రెండు స్ట్రింగ్‌లను పోల్చడానికి ఉపయోగించే జావాస్క్రిప్ట్ ముందే నిర్వచించిన పద్ధతి. ఇది కేస్-సెన్సిటివ్ స్ట్రింగ్ పోలికను నిర్వహిస్తుంది మరియు రెండు స్ట్రింగ్‌లను పోల్చడానికి ప్రస్తుత లొకేల్‌ను ఉపయోగిస్తుంది.
వాక్యనిర్మాణం
లొకేల్‌కంపేర్() పద్ధతిని ఉపయోగించి రెండు స్ట్రింగ్‌లను సరిపోల్చడానికి దిగువ పేర్కొన్న సింటాక్స్‌ని అనుసరించండి:
str1. లొకేల్ సరిపోల్చండి ( str2 ) ;ఇక్కడ, ' str2 ” అనేది స్ట్రింగ్‌తో పోల్చబడుతుంది str1 ”:
ఉదాహరణ
మేము ఇప్పుడు మునుపటి ఉదాహరణలో సృష్టించిన అదే స్ట్రింగ్‌లను ఉపయోగిస్తాము మరియు వాటిని ఉపయోగించి వాటిని సరిపోల్చండి లొకేల్ సరిపోల్చండి() షరతులతో కూడిన ఆపరేటర్ సహాయంతో పద్ధతి:
ఉంటే ( str1. లొకేల్ సరిపోల్చండి ( str2 ) ) {కన్సోల్. లాగ్ ( 'str1 str2కి సమానం' ) ;
} లేకపోతే {
కన్సోల్. లాగ్ ( 'str1 str2కి సమానం కాదు' ) ;
}
మీరు చూడగలిగినట్లుగా, అవుట్పుట్ స్ట్రింగ్‌లు సమానంగా ఉన్నాయని సూచిస్తుంది ఎందుకంటే పద్ధతి కేస్-ఇన్సెన్సిటివ్ పోలికను పోల్చింది:
తదుపరి పద్ధతికి వెళ్దాం!
విధానం 3: RegExp ఉపయోగించి రెండు స్ట్రింగ్‌లను టెస్ట్() పద్ధతితో సరిపోల్చండి
రెండు తీగలను పోల్చడానికి మరొక పద్ధతి ఉంది, అది కేస్-సెన్సిటివ్ పోలికను కూడా నిర్వహిస్తుంది ' RegExp '' సహాయంతో పరీక్ష () ” పద్ధతి. ఇది నిర్వచించిన రీజెక్స్ ఆధారంగా స్ట్రింగ్‌ల సమానత్వాన్ని తనిఖీ చేస్తుంది. పరీక్ష() పద్ధతి పోలిక కోసం స్ట్రింగ్‌ను ఆర్గ్యుమెంట్‌గా అంగీకరిస్తుంది.
వాక్యనిర్మాణం
పరీక్ష() పద్ధతితో RegExని ఉపయోగించి పరీక్ష() పద్ధతి కోసం ఇచ్చిన సింటాక్స్‌ని అనుసరించండి:
regPattern. పరీక్ష ( str2 ) ;ఇక్కడ, ' str2 ” అనేది స్ట్రింగ్‌తో పోల్చబడుతుంది regPattern ”:
ఉదాహరణ
ఇప్పుడు, మేము స్ట్రింగ్‌ను పాస్ చేయడం ద్వారా RegExp యొక్క ఉదాహరణను సృష్టిస్తాము ' str1 'మరియు ఒక రెజెక్స్' gi 'ఇది కేస్-సెన్సిటివ్ పోలికను సూచిస్తుంది మరియు దానిని వేరియబుల్‌లో నిల్వ చేస్తుంది' 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 ”:
మేము రెండు జావాస్క్రిప్ట్ స్ట్రింగ్‌లను పోల్చడానికి అన్ని పద్ధతులను కంపైల్ చేసాము.
ముగింపు
రెండు జావాస్క్రిప్ట్ స్ట్రింగ్‌లను పోల్చడం కోసం, మీరు లొకేల్‌కంపేర్() పద్ధతి, కఠినమైన సమానత్వ ఆపరేటర్, టెస్ట్() పద్ధతితో RegEx లేదా కలిగి() పద్ధతిని ఉపయోగించవచ్చు. స్ట్రిక్ట్ ఈక్వాలిటీ ఆపరేటర్ కేస్-సెన్సిటివ్ పోలికను నిర్వహిస్తుంది, అయితే పరీక్ష() పద్ధతి మరియు లొకేల్‌కంపేర్() పద్ధతి కేస్-సెన్సిటివ్ పోలికను నిర్వహిస్తాయి. చివరగా, కలిగి() పద్ధతి మరొక స్ట్రింగ్‌లో స్ట్రింగ్‌ను సబ్‌స్ట్రింగ్‌గా తనిఖీ చేస్తుంది. ఈ ఆర్టికల్‌లో, జావాస్క్రిప్ట్‌లోని రెండు స్ట్రింగ్‌లను సరైన ఉదాహరణలతో పోల్చే పద్ధతులను మేము ప్రదర్శించాము.