ప్రోగ్రామింగ్ ప్రపంచంలో స్ట్రింగ్స్ కీలక పాత్ర పోషిస్తాయి. ప్రోగ్రామర్ ప్రోగ్రామ్ యొక్క వినియోగదారుతో సమాచారాన్ని కమ్యూనికేట్ చేస్తున్నప్పుడు ఇవి ఉపయోగకరంగా ఉంటాయి. కొన్నిసార్లు, స్ట్రింగ్ యొక్క నిర్దిష్ట భాగం/స్లైస్‌ని తిరిగి పొందాల్సిన అవసరం ఉంది. జావాస్క్రిప్ట్ ఈ ప్రయోజనం కోసం వివిధ పద్ధతులను అందిస్తుంది ' string.slice()” మరియు “string.substring() ” పద్ధతులు.
ఈ పోస్ట్ వివరిస్తుంది:
- జావాస్క్రిప్ట్‌లో String.slice() అంటే ఏమిటి?
- JavaScriptలో String.substring() అంటే ఏమిటి?
- String.slice() మరియు String.substring()ని వేరు చేయండి
జావాస్క్రిప్ట్‌లో String.slice() అంటే ఏమిటి?
ది ' ముక్క () ” ఫంక్షన్ స్ట్రింగ్‌లోని కొంత భాగాన్ని ఎంచుకుని, ఆ భాగాన్ని కొత్త స్ట్రింగ్‌గా తిరిగి పొందుతుంది. సంగ్రహించిన భాగం ప్రారంభ మరియు ముగింపు పారామితులను ఉపయోగించి నిర్వచించబడుతుంది. ఈ పద్ధతిని ఉపయోగించడానికి, దిగువ పేర్కొన్న వాక్యనిర్మాణాన్ని అనుసరించండి:
స్ట్రింగ్. ముక్క ( ప్రారంభ సూచిక , ముగింపు సూచిక )
ఉదాహరణ:
ఈ పేర్కొన్న ఉదాహరణలో, ఒక వస్తువును తయారు చేసి, నిర్దిష్ట స్ట్రింగ్‌ను నిర్వచించిన వేరియబుల్ విలువగా పాస్ చేయండి:
స్ట్రింగ్ వీలు = 'Linux'
ఇక్కడ, ' ముక్క () 'పద్ధతి ప్రారంభ సూచికతో ప్రారంభించబడింది' 5 'మరియు ముగింపు సూచిక' 9 ”. ఇది పేర్కొన్న పరిధి ప్రకారం స్ట్రింగ్ యొక్క స్లైస్‌ను ఎంచుకుంటుంది మరియు దానిని మరొక వేరియబుల్‌లో నిల్వ చేస్తుంది:
స్ట్రింగ్స్లైస్ = స్ట్రింగ్. ముక్క ( 5 , 9 )
'ని పిలవండి console.log() ” పద్ధతి మరియు కన్సోల్‌లో ఫలితాన్ని ప్రదర్శించడానికి స్ట్రింగ్ యొక్క స్లైస్ నిల్వ చేయబడిన వేరియబుల్‌ను పాస్ చేయండి:
కన్సోల్. లాగ్ ( స్ట్రింగ్స్లైస్ )ఫలితంగా, స్ట్రింగ్ యొక్క స్లైస్ కన్సోల్‌లో ముద్రించబడుతుంది:
JavaScriptలో String.substring() అంటే ఏమిటి?
' లాంటిది ముక్క () 'పద్ధతి,' సబ్‌స్ట్రింగ్() ” జావాస్క్రిప్ట్‌లో కూడా ఇదే విధమైన వాక్యనిర్మాణం ఉంది. ది ' సబ్‌స్ట్రింగ్() ” పద్ధతి కొత్త స్ట్రింగ్‌గా చేయడానికి స్ట్రింగ్‌లోని ఒక విభాగాన్ని ఎంచుకుని, దానిని తిరిగి అందిస్తుంది. స్ట్రింగ్ యొక్క తిరిగి పొందిన భాగం ప్రారంభ మరియు ముగింపు పారామితుల సహాయంతో నిర్వచించబడింది:
తదేకంగా చూస్తున్నాడు. సబ్ స్ట్రింగ్ ( ప్రారంభ సూచిక , ముగింపు సూచిక )ఉదాహరణ
పెద్ద స్ట్రింగ్ నుండి సబ్‌స్ట్రింగ్‌ను పొందడానికి, జావాస్క్రిప్ట్ “ సబ్‌స్ట్రింగ్() ” పద్ధతిని ఉపయోగించవచ్చు. అలా చేయడానికి, ఒక వస్తువును తయారు చేసి, దానిలో ఒక స్ట్రింగ్‌ను నిల్వ చేయండి:
స్ట్రింగ్ వీలు = 'Linuxhint ఉత్తమ ట్యుటోరియల్ వెబ్‌సైట్'తరువాత, 'ని పిలవండి సబ్‌స్ట్రింగ్() ” పద్ధతి మరియు స్ట్రింగ్ నుండి సబ్‌స్ట్రింగ్‌ను పొందడానికి ప్రారంభ మరియు ముగింపు సూచికను సెట్ చేయండి:
సబ్ స్ట్రింగ్ = స్ట్రింగ్. సబ్ స్ట్రింగ్ ( 5 , 17 )చివరగా, అవుట్‌పుట్‌ను ప్రదర్శించడానికి సబ్‌స్ట్రింగ్ ఆబ్జెక్ట్‌ను “console.log()” పద్ధతికి పాస్ చేయండి:
కన్సోల్. లాగ్ ( సబ్ స్ట్రింగ్ )కన్సోల్‌లో సబ్‌స్ట్రింగ్ ప్రదర్శించబడడాన్ని గమనించవచ్చు:
ప్రారంభం మరియు స్టాప్ సమానంగా ఉంటే రెండు పద్ధతులు ఖాళీ స్ట్రింగ్‌ను తిరిగి అందిస్తాయి. స్టాప్ పరామితిని తీసివేయడం ద్వారా, రెండు ఫంక్షన్‌లు స్ట్రింగ్ చివరి వరకు అక్షరాలను తిరిగి పొందుతాయి. పేర్కొన్న పరామితి స్ట్రింగ్ పొడవును మించి ఉంటే, స్ట్రింగ్ యొక్క అసలు పొడవు ఉపయోగించబడుతుంది.
String.slice() మరియు String.substring()ని వేరు చేయాలా?
పేర్కొన్న ఫంక్షన్ల మధ్య కొన్ని ముఖ్యమైన వ్యత్యాసాలు క్రింద ఇవ్వబడ్డాయి:
| String.slice() | String.substring() |
|---|---|
| 'స్టింగ్. స్ట్రింగ్ యొక్క భాగాన్ని సంగ్రహించడానికి స్లైస్()” పద్ధతి ఉపయోగించబడుతుంది. | స్ట్రింగ్‌లోని సబ్‌స్ట్రింగ్‌ను తిరిగి పొందడానికి “string.substring()” పద్ధతి ఉపయోగించబడుతుంది. |
| ప్రారంభ సూచిక ప్రతికూలంగా మరియు ముగింపు సూచిక సానుకూలంగా ఉంటే స్ట్రింగ్ ఖాళీగా తిరిగి ఇవ్వబడుతుంది. | ప్రారంభం స్టాప్ కంటే ఎక్కువగా ఉంటే ఇది రెండు పారామితులను ఒకదానితో ఒకటి మారుస్తుంది. |
| ప్రారంభం ప్రతికూలంగా ఉంటే, అది “substr()” వంటి స్ట్రింగ్ చివరి నుండి అక్షరాన్ని సెట్ చేస్తుంది. | ఏదైనా ప్రతికూల లేదా NaN వాదన 0గా పరిగణించబడుతుంది. |
రెండవ మరియు మూడవ ప్రకటనలలో చర్చించబడిన ప్రాథమిక వ్యత్యాసాల ప్రకారం, మేము ఇప్పుడు కొన్ని ఉదాహరణలను పరిశీలిస్తాము. ఈ ఉదాహరణలలో, మేము రెండింటికి ప్రారంభంలో ఒక ప్రతికూల సూచికను పాస్ చేస్తాము ముక్క () ', మరియు' సబ్‌స్ట్రింగ్() ” పద్ధతులు మరియు ముగింపు సూచికగా సానుకూల సూచిక.
ఉదాహరణ 1: ఒక ప్రతికూల సూచిక (ప్రారంభ సూచికగా) మరియు సానుకూల ముగింపు సూచిక
స్లైస్() పద్ధతికి ప్రారంభ సూచికగా ఒక ప్రతికూల విలువను మరియు ముగింపు సూచికగా ఒక సానుకూల సూచికను పాస్ చేద్దాం. పర్యవసానంగా, పేర్కొన్న ఫంక్షన్ ఖాళీ స్ట్రింగ్‌ను అందిస్తుంది:
స్థిరంగా వాక్యం = 'Linuxhint చాలా ఉపయోగకరమైన వెబ్‌సైట్' ;వాక్యం. ముక్క ( - 7 , 5 ) ;
ఫలితంగా, ఖాళీ స్ట్రింగ్ కన్సోల్‌లో అవుట్‌పుట్‌గా ప్రదర్శించబడుతుంది:
మరోవైపు, లో ' సబ్‌స్ట్రింగ్() ', ఒక ప్రతికూల విలువ ప్రారంభ సూచికగా మరియు ఒక సానుకూల విలువ ముగింపు సూచికగా పాస్ అయినట్లయితే, అది ప్రారంభ సూచికగా పరిగణించబడుతుంది' 0 ” మరియు సబ్‌స్ట్రింగ్‌ను ముగింపు సూచికకు తిరిగి ఇవ్వండి:
స్థిరంగా వాక్యం = 'Linuxhint చాలా ఉపయోగకరమైన వెబ్‌సైట్' ;వాక్యం. సబ్ స్ట్రింగ్ ( - 7 , 5 ) ;
ఫలితంగా, అవుట్‌పుట్ కన్సోల్‌లో ప్రదర్శించబడుతుంది:
ఉదాహరణ 2: ఒక ప్రతికూల సూచిక మాత్రమే ఉత్తీర్ణత
మొదట, మేము స్థిరమైన రకం వస్తువును తయారు చేస్తాము ' వాక్యం మరియు స్ట్రింగ్‌ను పాస్ చేయండి:
స్థిరంగా వాక్యం = 'Linuxhint చాలా ఉపయోగకరమైన వెబ్‌సైట్' ;'ని ఉపయోగించండి ముక్క () ” పద్ధతి మరియు స్ట్రింగ్ చివరి నుండి స్ట్రింగ్ యొక్క భాగాన్ని పొందడానికి ఒకే ప్రతికూల సూచికను పాస్ చేయండి:
వాక్యం. ముక్క ( - 7 ) ;స్ట్రింగ్ చివర నుండి సబ్‌స్ట్రింగ్ స్ట్రింగ్‌లో భాగంగా తిరిగి ఇవ్వబడిందని గమనించవచ్చు:
అయినప్పటికీ, '' యొక్క వాదన వలె మనం అదే ప్రతికూల విలువను పాస్ చేస్తే సబ్‌స్ట్రింగ్() ” పద్ధతి ఇది అవుట్‌పుట్ వలె అదే స్ట్రింగ్‌ను అందిస్తుంది:
స్థిరంగా వాక్యం = 'Linuxhint చాలా ఉపయోగకరమైన వెబ్‌సైట్' ;వాక్యం. సబ్ స్ట్రింగ్ ( - 7 ) ;
JavaScriptలో String.slice, String.substring మరియు వాటి మధ్య వ్యత్యాసం గురించి అంతే.
ముగింపు
ది ' string.slice() 'మరియు' string.substring() ” రెండూ నిర్వచించబడిన స్ట్రింగ్ నుండి స్ట్రింగ్ యొక్క భాగాన్ని తిరిగి పొందడానికి ఉపయోగించబడతాయి. కానీ ఈ రెండు పద్ధతుల మధ్య ప్రధాన వ్యత్యాసం ' string.slice() ప్రారంభ సూచిక స్టాప్ కంటే ఎక్కువగా ఉంటే ” పద్ధతి ఖాళీ స్ట్రింగ్‌ని అందిస్తుంది. మరోవైపు, ' string.substring() ”ప్రారంభం స్టాప్ కంటే ఎక్కువగా ఉంటే రెండు పారామితులను మారుస్తుంది. ఈ పోస్ట్ ' మధ్య వ్యత్యాసాన్ని పేర్కొంది స్ట్రింగ్.స్లైస్ 'మరియు' స్ట్రింగ్. సబ్ స్ట్రింగ్ ” ఆచరణాత్మక ఉదాహరణలను ఉపయోగించి.