స్ట్రింగ్‌లు ముఖ్యమైన డేటా రకం మరియు దాదాపు అన్ని ప్రధాన ప్రోగ్రామింగ్ భాషలలో ఉన్నాయి. డేటా నిల్వ మరియు తారుమారు చేయడంలో వారు కీలక పాత్ర పోషిస్తారు. JavaScript స్ట్రింగ్‌లు అనేక బిల్ట్ మెథడ్స్‌తో వస్తాయి, వీటిని నిర్వహించడానికి మరియు వాటిని మార్చేందుకు ఉపయోగించవచ్చు. ది ముక్క () పద్ధతి అటువంటి పద్ధతులలో ఒకటి.
స్లైస్ () పద్ధతి
ది ముక్క () జావాస్క్రిప్ట్‌లోని పద్ధతి అసలు స్ట్రింగ్‌ను సవరించకుండా అవసరమైన సబ్‌స్ట్రింగ్ యొక్క ప్రారంభ మరియు ముగింపు సూచికను పాస్ చేయడం ద్వారా స్ట్రింగ్ నుండి సబ్‌స్ట్రింగ్‌ను పొందడానికి ఉపయోగించబడుతుంది.
స్లైస్() పద్ధతి యొక్క సింటాక్స్
str.స్లైస్ ( ప్రారంభ స్థానం, ముగింపు స్థానం )
ది ముక్క () పద్ధతి డాట్ ఆపరేటర్ సహాయంతో స్ట్రింగ్‌పై వర్తించబడుతుంది. దీనికి అసలు స్ట్రింగ్‌లోని సబ్‌స్ట్రింగ్ యొక్క ప్రారంభ మరియు ముగింపు స్థానం అనే రెండు పారామీటర్‌లతో పాటు స్ట్రింగ్ పేరు అవసరం. రెండవ వాదన అంటే, సబ్‌స్ట్రింగ్ యొక్క ముగింపు స్థానం పూర్తిగా ఐచ్ఛికం అని గమనించడం ఆసక్తికరంగా ఉంటుంది.
విధానం 1: రెండు వాదనలను పాస్ చేయడం ద్వారా స్లైస్ () పద్ధతిని ఉపయోగించడం
మొదటి పద్ధతిలో, మేము ఉపయోగిస్తాము ముక్క () ప్రారంభ మరియు ముగింపు సూచిక రెండింటినీ దాటడం ద్వారా పద్ధతి.
var originalString = 'JavaScript string.slice() విధానం - LinuxHint' ;
var subString = originalString.slice ( 35 , 40 ) ;
console.log ( సబ్ స్ట్రింగ్ ) ;
console.log ( అసలైన స్ట్రింగ్ ) ;
స్ట్రింగ్‌ను నిల్వ చేయడానికి మేము మొదట అసలు స్ట్రింగ్ అనే వేరియబుల్‌ని సృష్టించాము. మేము మరొక వేరియబుల్‌ని సృష్టించాము మరియు ఉపయోగించాము ముక్క () దానికి విలువను కేటాయించే పద్ధతి. మేము సబ్‌స్ట్రింగ్ యొక్క ప్రారంభ సూచికగా 35 మరియు ముగింపు సూచికగా 40ని దాటాము. మేము కన్సోల్‌లో సబ్‌స్ట్రింగ్ విలువను చూపించడానికి console.log() పద్ధతిని ఉపయోగించాము. చివరగా, ఒరిజినల్ స్ట్రింగ్ మారకుండా ఉందని చూపడానికి మేము ఒరిజినల్ స్ట్రింగ్ విలువను కన్సోల్‌కి లాగిన్ చేసాము.
విధానం 2: ఒకే వాదనను పాస్ చేయడం ద్వారా స్లైస్() పద్ధతిని ఉపయోగించడం
ది ముక్క పద్ధతి కూడా ఒక వాదనతో మాత్రమే పని చేస్తుంది. ఒకే వాదనను ఆమోదించినట్లయితే ముక్క () పద్ధతి అప్పుడు దానిని ప్రారంభ సూచికగా తీసుకుంటుంది మరియు ముగింపు సూచిక డిఫాల్ట్‌గా స్ట్రింగ్ ముగింపు:
var originalString = 'JavaScript string.slice() విధానం - LinuxHint' ;
var subString = originalString.slice ( 35 ) ;
console.log ( సబ్ స్ట్రింగ్ ) ;
విధానం 3: ప్రతికూల విలువను ఆర్గ్యుమెంట్‌గా పాస్ చేయడం ద్వారా స్లైస్ () పద్ధతిని ఉపయోగించడం
మేము స్లైస్ పద్ధతికి ప్రతికూల విలువను ఆర్గ్యుమెంట్‌గా పాస్ చేస్తే, అది స్ట్రింగ్ చివరి నుండి ఇండెక్సింగ్‌ను ప్రారంభిస్తుంది:
var originalString = 'JavaScript string.slice() విధానం - LinuxHint' ;var subString = originalString.slice ( - 9 ) ;
console.log ( సబ్ స్ట్రింగ్ ) ;
మేము రెండు ప్రతికూల వాదనలను కూడా పాస్ చేయవచ్చు:
var subString = originalString.slice ( - 9 , - 4 ) ;
console.log ( సబ్ స్ట్రింగ్ ) ;
సరికాని వాదనలు:
ది ముక్క () ప్రారంభ సూచిక స్ట్రింగ్ ముగింపు సూచిక కంటే ఎక్కువగా ఉంటే, పద్ధతి ఖాళీ స్ట్రింగ్‌ను అందిస్తుంది:
var originalString = 'JavaScript string.slice() విధానం - LinuxHint' ;var subString = originalString.slice ( 35 , 30 ) ;
console.log ( సబ్ స్ట్రింగ్ ) ;
ది ముక్క () ప్రారంభ సూచిక అసలు స్ట్రింగ్ పొడవు కంటే ఎక్కువగా ఉంటే, పద్ధతి ఖాళీ స్ట్రింగ్‌ను కూడా అందిస్తుంది:
ముగింపు
అంతర్నిర్మిత str.slice() ప్రారంభ స్థానం/సూచిక మరియు ఐచ్ఛిక ముగింపు స్థానం/సూచికను పాస్ చేయడం ద్వారా స్ట్రింగ్ నుండి సబ్‌స్ట్రింగ్‌ను పొందడానికి పద్ధతి ఉపయోగించబడుతుంది. ఈ వ్యాసంలో మేము సాధ్యమయ్యే ప్రతి ఉపయోగాన్ని ప్రయత్నించాము ముక్క () విభిన్న వాదనలతో ఇది ఎలా ప్రవర్తిస్తుందో చూడటానికి తగిన ఉదాహరణలతో కూడిన పద్ధతి.