కోడ్ వ్రాస్తున్నప్పుడు, నిర్దిష్ట పనులు పూర్తయ్యాయని నిర్ధారించుకోవడానికి డెవలపర్ తరచుగా రెండు స్ట్రింగ్‌లను సరిపోల్చాల్సి ఉంటుంది. క్యాపిటల్ మరియు చిన్న అక్షరాలు వంటి వాటి కేసులపై శ్రద్ధ చూపకుండా స్ట్రింగ్‌లను పోల్చడాన్ని కేస్-సెన్సిటివ్ పోలిక అంటారు. అనేక భాషలు కేస్ సెన్సిటివిటీ మరియు ఇన్‌సెన్సిటివిటీతో స్ట్రింగ్ పోలికను సపోర్ట్ చేస్తాయి.
ఈ కథనం జావాస్క్రిప్ట్‌లోని స్ట్రింగ్‌ల కేస్-సెన్సిటివ్ పోలిక కోసం పద్ధతులను వివరిస్తుంది.
జావాస్క్రిప్ట్‌లో సెన్సిటివ్ స్ట్రింగ్ పోలికను ఎలా కేస్ చేయాలి?
జావాస్క్రిప్ట్‌లోని స్ట్రింగ్‌ల యొక్క కేస్-ఇన్సెన్సిటివ్ పోలిక కోసం, క్రింది ముందే నిర్వచించిన పద్ధతులను ఉపయోగించండి:
-
- localeCompare() పద్ధతి
- toUpperCase() మరియు toLowerCase() పద్ధతి
- పరీక్ష() పద్ధతితో రెగ్యులర్ వ్యక్తీకరణ
పైన పేర్కొన్న ప్రతి విధానం యొక్క పనిని విడిగా చూద్దాం.
విధానం 1: లొకేల్‌కంపేర్() పద్ధతిని ఉపయోగించి కేస్ ఇన్సెన్సిటివ్ స్ట్రింగ్ కంపారిజన్
స్ట్రింగ్స్ యొక్క కేస్-సెన్సిటివ్ పోలిక 'ని ఉపయోగిస్తుంది లొకేల్ సరిపోల్చండి() ” పద్ధతి. ఈ పద్ధతి సంఖ్యను అందిస్తుంది (పాజిటివ్, నెగటివ్ లేదా జీరో). స్ట్రింగ్స్ సార్టింగ్ ఆర్డర్‌లో పోల్చబడతాయి, రిఫరెన్స్ స్ట్రింగ్ కంపారిజన్ స్ట్రింగ్ కంటే పొడవుగా ఉంటే లేదా పోల్చిన స్ట్రింగ్ తర్వాత వచ్చినట్లయితే, అది పాజిటివ్ నంబర్‌ను ఇస్తుంది. రిఫరెన్స్ స్ట్రింగ్ తక్కువగా ఉంటే లేదా పోల్చబడిన స్ట్రింగ్ కంటే ముందు వచ్చినట్లయితే, అది ప్రతికూల సంఖ్యను అందిస్తుంది. రిఫరెన్స్ స్ట్రింగ్ పోల్చబడిన స్ట్రింగ్‌కు సమానం అయితే సున్నా తిరిగి ఇవ్వాలి.
వాక్యనిర్మాణం
localeCompare() పద్ధతి కోసం అందించబడిన వాక్యనిర్మాణాన్ని అనుసరించండి:
string1.localeCompare ( string2, లొకేల్స్, ఎంపికలు )
ఇక్కడ,
-
- ' స్ట్రింగ్2 ” అనేది కంపేర్ స్ట్రింగ్, ఇక్కడ స్ట్రింగ్ 1 పోల్చబడుతుంది.
- ' స్థానిక ” అనేది భాష ట్యాగ్.
- ' ఎంపికలు ” అనేవి వినియోగదారు దానితో పని చేస్తున్నప్పుడు అందించిన లొకేల్.
ఉదాహరణ
రెండు తీగలను సృష్టించండి' స్ట్రింగ్1 'మరియు' స్ట్రింగ్2 ', తీగలతో' linuxhint 'మరియు' LinuxHint ”వరుసగా:
var స్ట్రింగ్1 = 'linux' ;var స్ట్రింగ్2 = 'LinuxHint' ;
“ని ఉపయోగించి string1ని string2తో సరిపోల్చండి లొకేల్ సరిపోల్చండి() 'పద్ధతి మరియు ఫలితాన్ని వేరియబుల్‌లో నిల్వ చేయండి' కంప్ ”. పద్ధతి యొక్క మూడవ వాదన ఇలా సెట్ చేయబడుతుంది ' సున్నితత్వం: 'బేస్' ” పోల్చబడిన స్ట్రింగ్స్ బేస్ లెటర్స్ భిన్నంగా లేవని సూచిస్తుంది:
షరతులతో కూడిన స్టేట్‌మెంట్‌లో, లొకేల్‌కంపేర్() పద్ధతి యొక్క తిరిగి వచ్చిన విలువ సున్నాకి సమానమైనదా అని తనిఖీ చేయండి, అది ' తీగలు సమానంగా ఉంటాయి ', లేకపోతే, ' తీగలు సమానంగా లేవు ”:
console.log ( 'తీగలు సమానం' ) ;
} లేకపోతే {
console.log ( 'తీగలు సమానంగా లేవు' ) ;
}
అవుట్‌పుట్
విధానం 2: కేస్ ఇన్సెన్సిటివ్ స్ట్రింగ్ కంపారిజన్ టు అప్పర్‌కేస్() మరియు టులోవర్‌కేస్() పద్ధతిని ఉపయోగించి
కేస్ ఇన్సెన్సిటివ్ స్ట్రింగ్‌లను పోల్చడానికి ఎక్కువగా ఉపయోగించే విధానాలు toUpperCase() method or toLowerCase() Method. వారు స్ట్రింగ్‌లను పెద్ద అక్షరం లేదా చిన్న అక్షరాల్లోకి మారుస్తారు మరియు వాటిని కఠినమైన సమానత్వ ఆపరేటర్ల సహాయంతో పోల్చారు.
వాక్యనిర్మాణం
ToUpperCase() పద్ధతి కోసం, క్రింది పద్ధతిని ఉపయోగించండి:
string.to UpperCase ( ) ;
toLowerCase() పద్ధతి కోసం దిగువ వాక్యనిర్మాణాన్ని ఉపయోగించండి.
ఉదాహరణ: కేస్ ఇన్సెన్సిటివ్ స్ట్రింగ్ కంపారిజన్ టుఅప్పర్‌కేస్() పద్ధతిని ఉపయోగించి
పైన సృష్టించబడిన తీగలను పరిగణించండి ' స్ట్రింగ్1 'మరియు' స్ట్రింగ్2 ” ఆపై వాటిని toUpperCase() పద్ధతిని ఉపయోగించి కఠినమైన సమానత్వ ఆపరేటర్‌తో సరిపోల్చండి:
ఉంటే ( string1.toupperCase ( ) === string2.toUpperCase ( ) ) {console.log ( 'తీగలు సమానం' ) ;
} లేకపోతే {
console.log ( 'తీగలు సమానంగా లేవు' ) ;
}
కేసును విస్మరించడం ద్వారా రెండు స్ట్రింగ్‌లు సమానంగా ఉన్నాయని అవుట్‌పుట్ సూచిస్తుంది:
ఉదాహరణ: లోవర్‌కేస్() పద్ధతిని ఉపయోగించి కేస్ ఇన్సెన్సిటివ్ స్ట్రింగ్ కంపారిజన్
ఇక్కడ, తీగలను toLowerCase() పద్ధతిని ఉపయోగించి పోల్చారు, అది మొదట స్ట్రింగ్‌లను చిన్న అక్షరం లోకి మారుస్తుంది మరియు తర్వాత వాటిని === ఆపరేటర్‌ని ఉపయోగించి సరిపోల్చండి:
ఉంటే ( string1.toLowerCase ( ) === string2.toLowerCase ( ) ) {console.log ( 'తీగలు సమానం' ) ;
} లేకపోతే {
console.log ( 'తీగలు సమానంగా లేవు' ) ;
}
సంబంధిత అవుట్‌పుట్ ఇలా ఉంటుంది:
విధానం 3: పరీక్ష() విధానంతో రెగ్యులర్ ఎక్స్‌ప్రెషన్‌ని ఉపయోగించి కేస్-ఇన్సెన్సిటివ్ స్ట్రింగ్ కంపారిజన్
ముందే నిర్వచించబడిన జావాస్క్రిప్ట్ ' పరీక్ష () ” పద్ధతి, ఇది సాధారణ వ్యక్తీకరణను ఉపయోగిస్తుంది, రెండు తీగలను పోల్చడానికి మరొక మార్గం. పేర్కొన్న రీజెక్స్ ఆధారంగా, స్ట్రింగ్‌లు సమానంగా ఉన్నాయా లేదా అనేది నిర్ణయిస్తుంది.
వాక్యనిర్మాణం
స్ట్రింగ్‌లను సరిపోల్చడానికి సాధారణ వ్యక్తీకరణను ఉపయోగించడం కోసం ఇచ్చిన సింటాక్స్‌ను అనుసరించండి:
RegExp ( తీగ, 'జి' )
ఇక్కడ,
-
- ' RegExp ' ఉన్నచో ' సాధారణ వ్యక్తీకరణ ”.
- ' g ” అనేది అన్ని స్ట్రింగ్‌లను తనిఖీ చేయడానికి అనుమతించే గ్లోబల్ వేరియబుల్.
- ' i ” అనేది ఫ్లాగ్ వేరియబుల్, ఇది నమూనాతో సరిపోలడానికి స్ట్రింగ్‌ను ఉపయోగిస్తున్నప్పుడు కేసును విస్మరించబడాలని సూచిస్తుంది.
ఉదాహరణ
ముందుగా, ఒక స్ట్రింగ్ మరియు సాధారణ వ్యక్తీకరణను ఆర్గ్యుమెంట్‌గా పాస్ చేయడం ద్వారా RegExp() యొక్క కొత్త వస్తువును సృష్టించండి:
var comp = కొత్త RegExp ( స్ట్రింగ్ 1, 'జి' ) ;
పరీక్ష() పద్ధతిని ఉపయోగించి తీగలను సరిపోల్చండి:
console.log ( 'తీగలు సమానం' ) ;
} లేకపోతే {
console.log ( 'తీగలు సమానంగా లేవు' ) ;
}
అవుట్‌పుట్
ముగింపు
జావాస్క్రిప్ట్‌లో కేస్ ఇన్సెన్సిటివ్ స్ట్రింగ్‌లను పోల్చడానికి, లొకేల్‌కంపేర్() పద్ధతి, టోఅప్పర్‌కేస్() మరియు టోలోవర్‌కేస్() పద్ధతి లేదా రెగ్యులర్ ఎక్స్‌ప్రెషన్‌తో టెస్ట్() పద్ధతితో సహా జావాస్క్రిప్ట్ ముందే నిర్వచించిన పద్ధతులను ఉపయోగించండి. రెండు కేస్-సెన్సిటివ్ స్ట్రింగ్‌లను పోల్చడానికి “toUpperCase() మరియు toLowerCase()” పద్ధతులు ఎక్కువగా ఉపయోగించే విధానం. ఈ కథనం జావాస్క్రిప్ట్‌లోని స్ట్రింగ్‌ల కేస్-సెన్సిటివ్ పోలిక కోసం వివిధ మార్గాలను వివరించింది.