ఈ రైట్-అప్ స్ట్రింగ్ నుండి లీడింగ్ సున్నాలను తొలగించే పద్ధతులను ప్రదర్శిస్తుంది.
జావాస్క్రిప్ట్‌లోని స్ట్రింగ్ నుండి లీడింగ్ జీరోలను ఎలా తొలగించాలి?
స్ట్రింగ్ నుండి ప్రముఖ సున్నాలను తీసివేయడానికి, దిగువ జాబితా చేయబడిన పద్ధతులను ఉపయోగించండి:
- parseInt() పద్ధతి
- parseFloat() పద్ధతి
- భర్తీ () పద్ధతి
- సంఖ్య కన్స్ట్రక్టర్
- స్ట్రింగ్‌ను 1తో గుణించండి
ప్రతి పద్ధతి యొక్క పనిని విడిగా పరిశీలిద్దాం.
విధానం 1: parseInt() పద్ధతిని ఉపయోగించి స్ట్రింగ్ నుండి లీడింగ్ జీరోలను తొలగించండి
ది ' parseInt() పూర్ణాంక విలువలను కలిగి ఉన్న స్ట్రింగ్ నుండి లీడింగ్ సున్నాలను తీసివేయడానికి ” పద్ధతి ఉపయోగించబడుతుంది. ఇది స్ట్రింగ్‌ను ఆర్గ్యుమెంట్‌గా అంగీకరిస్తుంది మరియు లీడింగ్ సున్నాలను తీసివేసిన తర్వాత దాన్ని అవుట్‌పుట్‌గా ఇస్తుంది.
వాక్యనిర్మాణం
parseInt() పద్ధతిని ఉపయోగించడానికి ఇచ్చిన సింటాక్స్‌ని అనుసరించండి:
parseInt ( strng ) ;
ఇచ్చిన పద్ధతి గురించి మరింత తెలుసుకోవడానికి క్రింది ఉదాహరణను చూడండి.
ఉదాహరణ
మొదట, మేము సున్నాలతో ప్రారంభమయ్యే సంఖ్యలను కలిగి ఉన్న స్ట్రింగ్‌ను సృష్టిస్తాము:
ఉంది strng = '0010100' ;
అప్పుడు, మేము స్ట్రింగ్‌ను మెథడ్‌కు పాస్ చేయడం ద్వారా లీడింగ్ సున్నాలను తొలగించడానికి పార్స్ఇంట్() పద్ధతిని పిలుస్తాము మరియు దానిని '' అనే వేరియబుల్‌లో నిల్వ చేస్తాము. తిమ్మిరి ”:
ఉంది తిమ్మిరి = parseInt ( strng ) ;చివరగా, కన్సోల్‌లో తిరిగి వచ్చిన విలువను ప్రింట్ చేయండి:
కన్సోల్. లాగ్ ( తిమ్మిరి ) ;ఇచ్చిన అవుట్‌పుట్ స్ట్రింగ్ నుండి లీడింగ్ సున్నాలు విజయవంతంగా తీసివేయబడిందని సూచిస్తుంది:
మీరు స్ట్రింగ్‌లోని ఫ్లోటింగ్ పాయింట్ నంబర్ నుండి లీడింగ్ సున్నాలను తీసివేయాలనుకుంటే, తదుపరి ఇవ్వబడిన విభాగాన్ని చూడండి.
విధానం 2: పార్స్‌ఫ్లోట్() పద్ధతిని ఉపయోగించి స్ట్రింగ్ నుండి లీడింగ్ జీరోలను తొలగించండి
ఫ్లోటింగ్ పాయింట్ నంబర్‌ను కలిగి ఉన్న స్ట్రింగ్ నుండి లీడింగ్ సున్నాలను తొలగించడానికి, ' ప్రెస్ఫ్లోట్() ” పద్ధతి. ఇది స్ట్రింగ్‌ను వాదనగా కూడా అంగీకరిస్తుంది.
వాక్యనిర్మాణం
parseFloat() పద్ధతిని ఉపయోగించడానికి క్రింది వాక్యనిర్మాణాన్ని అనుసరించండి:
ఉదాహరణ
ఇక్కడ, మేము సున్నాలకు దారితీసే దశాంశ సంఖ్యను కలిగి ఉన్న స్ట్రింగ్‌ను సృష్టిస్తాము:
అప్పుడు, పార్స్‌ఫ్లోట్() పద్ధతిని దానిలోని స్ట్రింగ్‌ను ఆర్గ్యుమెంట్‌గా పాస్ చేయడం ద్వారా కాల్ చేయండి మరియు ఫలిత విలువను వేరియబుల్‌లో నిల్వ చేస్తుంది “ తిమ్మిరి ”:
ఉంది తిమ్మిరి = ప్రెస్ఫ్లోట్ ( strng ) ;చివరగా, మేము 'ని ఉపయోగించి కన్సోల్‌లో ఫలిత విలువను ముద్రిస్తాము. console.log() 'పద్ధతి:
కన్సోల్. లాగ్ ( తిమ్మిరి ) ;ఇచ్చిన అవుట్‌పుట్ స్ట్రింగ్ నుండి దారితీసే సున్నాలు విజయవంతంగా తీసివేయబడిందని మీరు చూడగలరు:
తదుపరి పద్ధతి వైపు వెళ్దాం!
విధానం 3: రీప్లేస్() పద్ధతిని ఉపయోగించి స్ట్రింగ్ నుండి లీడింగ్ జీరోలను తొలగించండి
మీరు ఉపయోగించవచ్చు ' భర్తీ () ” స్ట్రింగ్ నుండి లీడింగ్ సున్నాలను తొలగించే పద్ధతి. ఈ పద్ధతి ఆ రీజెక్స్ ఆధారంగా ఏదైనా భర్తీ చేయడానికి సహాయపడే నమూనా లేదా రీజెక్స్‌ని ఉపయోగిస్తుంది.
వాక్యనిర్మాణం
భర్తీ() పద్ధతి కోసం క్రింది వివరించిన పద్ధతి ఉపయోగించబడుతుంది:
ఇక్కడ, ' రెజెక్స్ 'ఏదైనా భర్తీ చేయడానికి సహాయపడే నమూనా' భర్తీ చేసేవాడు ”.
ఉదాహరణ
ఈ ఉదాహరణలో, ముందుగా మనం “” అనే స్ట్రింగ్‌ను సృష్టిస్తాము. strng ” మరియు దానికి ప్రముఖ సున్నాలు ఉన్న విలువను కేటాయించండి:
అప్పుడు, మేము రెండు పారామితులను పాస్ చేయడం ద్వారా భర్తీ () పద్ధతిని పిలుస్తాము; రీజెక్స్, ఇది స్ట్రింగ్ నుండి లీడింగ్ సున్నాలను తొలగించడానికి ఉపయోగించబడుతుంది మరియు రీప్లేసర్‌గా పనిచేసే ఖాళీ స్ట్రింగ్:
ఉంది తిమ్మిరి = strng. భర్తీ చేయండి ( /^0+/ , '' ) ;చివరగా, మేము '' ఉపయోగించి ఫలిత విలువను ప్రింట్ చేస్తాము console.log() 'పద్ధతి:
కన్సోల్. లాగ్ ( తిమ్మిరి ) ; అవుట్‌పుట్
స్ట్రింగ్ నుండి ప్రముఖ సున్నాలను తొలగించడానికి కొన్ని ఇతర పద్ధతులను అర్థం చేసుకోవడానికి ముందుకు వెళ్దాం.
విధానం 4: నంబర్ కన్స్ట్రక్టర్ని ఉపయోగించి స్ట్రింగ్ నుండి లీడింగ్ జీరోలను తీసివేయండి
సంఖ్య() కన్స్ట్రక్టర్ స్ట్రింగ్‌ను ఆర్గ్యుమెంట్‌గా తీసుకుంటుంది మరియు స్ట్రింగ్ ప్రారంభం నుండి సున్నాని కత్తిరించడం ద్వారా సంఖ్యను అందిస్తుంది.
వాక్యనిర్మాణం
నంబర్ కన్స్ట్రక్టర్ని ఉపయోగించడానికి క్రింది సింటాక్స్‌ని ఉపయోగించండి:
ఉదాహరణ
మేము '' పేరుతో కొత్త స్ట్రింగ్‌ని సృష్టిస్తాము strng 'మరియు విలువను కేటాయించండి' 000100 ”:
ఆపై, స్ట్రింగ్‌ను నంబర్ కన్‌స్ట్రక్టర్‌కి పంపండి, ఇది స్ట్రింగ్ నుండి ప్రారంభ సున్నాలను తీసివేస్తుంది:
ఉంది తిమ్మిరి = సంఖ్య ( strng ) ;వేరియబుల్‌లో నిల్వ చేయబడిన ఫలిత విలువను ముద్రించండి ' తిమ్మిరి ”:
కన్సోల్. లాగ్ ( తిమ్మిరి ) ;మీరు అవుట్‌పుట్‌లో చూడగలిగినట్లుగా, స్ట్రింగ్ నుండి ప్రారంభ సున్నాలు తీసివేయబడతాయి:
స్ట్రింగ్ నుండి సున్నాలను తొలగించడానికి మరొక విధానాన్ని చూద్దాం.
విధానం 5: స్ట్రింగ్ నుండి లీడింగ్ జీరోలను 1తో గుణించడం ద్వారా తొలగించండి
''తో స్ట్రింగ్‌ను గుణించడం ద్వారా మీరు సంఖ్యకు ముందు ఉంచిన సున్నాలను తీసివేయవచ్చు 1 ”. స్ట్రింగ్ ఒకదానితో గుణించినప్పుడు, అది ప్రారంభ సున్నాలను తీసివేసి, వాస్తవ సంఖ్యను అందిస్తుంది.
వాక్యనిర్మాణం
స్ట్రింగ్ నుండి లీడింగ్ సున్నాలను తొలగించడానికి ఇచ్చిన సింటాక్స్‌ని అనుసరించండి:
ఉదాహరణ
మేము ఒక స్ట్రింగ్‌ను సృష్టిస్తాము' strng 'విలువతో' 001020 ”:
ఆపై, స్ట్రింగ్‌ను ఒకదానితో గుణించి, దానిని వేరియబుల్‌లో నిల్వ చేయండి ' తిమ్మిరి ”:
ఉంది తిమ్మిరి = strng * 1 ;'ని ఉపయోగించి ఫలిత విలువను ముద్రించండి console.log() 'పద్ధతి:
కన్సోల్. లాగ్ ( తిమ్మిరి ) ; అవుట్‌పుట్
మేము స్ట్రింగ్ నుండి ప్రముఖ సున్నాలను తొలగించడానికి వివిధ పద్ధతులను సేకరించాము.
ముగింపు
స్ట్రింగ్ నుండి లీడింగ్ సున్నాలను తీసివేయడం కోసం, మీరు parseInt() పద్ధతిని, parseFloat() పద్ధతిని, భర్తీ() పద్ధతిని, సంఖ్య() కన్స్ట్రక్టర్ని ఉపయోగించవచ్చు లేదా స్ట్రింగ్‌ను 1తో గుణించవచ్చు. parseInt() పద్ధతి లీడింగ్‌ని తీసివేయడం ద్వారా int విలువను అందిస్తుంది. సున్నాలు, అయితే పార్స్‌ఫ్లోట్() పద్ధతి ప్రముఖ సున్నాలను కత్తిరించడం ద్వారా ఫ్లోటింగ్ పాయింట్ సంఖ్యను ఇస్తుంది. పునఃస్థాపన() పద్ధతి సున్నాలను తొలగించడానికి regexని ఉపయోగిస్తుంది. ఈ రైట్-అప్‌లో, స్ట్రింగ్ నుండి లీడింగ్ సున్నాలను తొలగించడానికి మేము వివిధ పద్ధతులను ప్రదర్శించాము.