లోయర్‌కేస్ ఫంక్షన్‌కు జావాస్క్రిప్ట్

Javascript Tolowercase Function



జావాస్క్రిప్ట్ ఒక ప్రముఖ స్క్రిప్టింగ్ లేదా ప్రోగ్రామింగ్ లాంగ్వేజ్. ప్రోగ్రామర్లు తరచుగా డేటాను తారుమారు చేయడానికి లేదా నిర్వహించడానికి జావాస్క్రిప్ట్‌ను ఉపయోగిస్తారు. ఉదాహరణకు, ఒక HTML ఫారమ్‌లోని ఫీల్డ్‌లలో మీరు వినియోగదారు నుండి కొంత డేటాను పొందుతున్నారని చెప్పండి. వినియోగదారు నుండి డేటాను పొందుతున్నప్పుడు, యూజర్ టైప్ చేస్తున్న దాన్ని మీరు నియంత్రించలేరు. కానీ, మీరు డేటాను మంచి ఫార్మాట్‌లో చూపించాలి. వినియోగదారులు అవసరం లేని చోట పెద్ద అక్షరాలను ఇన్‌పుట్ చేయవచ్చు లేదా దీనికి విరుద్ధంగా. డేటాబేస్‌కు డేటాను సేవ్ చేస్తున్నప్పుడు లేదా డేటాను వెబ్ పేజీకి చూపించేటప్పుడు, ప్రోగ్రామర్‌గా, ఈ ఫంక్షన్‌ను జాగ్రత్తగా చూసుకోవడం అవసరం. ఈ ప్రయోజనం కోసం, స్ట్రింగ్‌ని లోయర్-కేస్ లెటర్స్‌గా మార్చడం కోసం లోవర్‌కేస్ () కు జావాస్క్రిప్ట్ అంతర్నిర్మిత ఫంక్షన్ ఉంది.

వాక్యనిర్మాణం

జావాస్క్రిప్ట్ నుండి లోయర్‌కేస్ () ఫంక్షన్ కోసం వాక్యనిర్మాణం క్రింది విధంగా ఉంది:







స్ట్రింగ్.దిగువ కేసు();

ది దిగువ కేసు () ఫంక్షన్ స్ట్రింగ్‌లోని అన్ని అక్షరాలను చిన్న అక్షరాలలోకి మారుస్తుంది. ఈ ఫంక్షన్ వేరియబుల్ యొక్క అసలు విలువను మార్చదు. బదులుగా, ఫంక్షన్ ఉదాహరణ కోసం కొత్త స్ట్రింగ్‌ను సృష్టిస్తుంది. ఈ విధంగా, ఫంక్షన్ ఏ వాదనలను తీసుకోదు, అయినప్పటికీ కుండలీకరణాలు () వాదనలు తీసుకోవడానికి ఉపయోగించబడతాయి. కానీ, దానితో చిన్న అక్షరం () ఫంక్షన్, మీరు ఫంక్షన్ యొక్క అదే సంప్రదాయాలను అనుసరిస్తారు.
ఇప్పుడు మనం కొన్ని ఉదాహరణలను చూద్దాం.



ఉదాహరణలు

కింది స్ట్రింగ్ వంటి కొన్ని పెద్ద అక్షరాలు మరియు చిన్న అక్షరాలతో కూడిన స్ట్రింగ్ ఉందని అనుకుందాం:



str లెట్= 'LinuxHint కి స్వాగతం.'


కానీ, మేము స్ట్రింగ్‌ను పూర్తిగా లోయర్-కేస్ అక్షరాలకు మార్చాలి. కాబట్టి, మేము ఈ క్రింది వాటిని వర్తింపజేస్తాము:





p.దిగువ కేసు();


మీరు గమనిస్తే, స్ట్రింగ్ ఫార్మాట్ చేయబడిన స్ట్రింగ్‌గా మార్చబడింది. అన్ని అక్షరాలు ఇప్పుడు లోయర్ కేస్ ఫార్మాట్‌లో ఉన్నాయి. ఇది అంత సులభం.

ఈ ఫంక్షన్ స్ట్రింగ్ కోసం. కానీ, ఇది ఇక్కడ మాత్రమే పరిమితం/పరిమితం కాదు. మేము ఫంక్షన్‌ను స్ట్రింగ్‌ల శ్రేణికి మరియు స్ట్రింగ్‌లను కలిగి ఉన్న వస్తువుల శ్రేణికి కూడా వర్తింపజేయవచ్చు.



మనం చూద్దాం:
ముందుగా, మేము ఈ క్రింది విధంగా తీగల శ్రేణిని వ్రాస్తాము:

లెట్= ['హాయ్', 'LinuxHint', 'గ్రేట్']


ఇప్పుడు, గ్రేట్ అనే పదాన్ని అన్ని చిన్న అక్షరాలకు మార్చడానికి, మేము ఈ క్రింది వాటిని వర్తింపజేస్తాము:

అరె[2].దిగువ కేసు();

ఇక్కడ '2' అనేది గ్రేట్ యొక్క సూచిక.

మీరు గమనిస్తే, ఇప్పుడు, గ్రేట్ అనే పదం చిన్న అక్షరాలకు మార్చబడింది. మేము మరో రెండు స్ట్రింగ్‌ల కోసం ఇలాంటిదే చేసాము: హాయ్ అనే పదానికి [0] మరియు LinuxHint అనే పదానికి [1].
వస్తువులు స్ట్రింగ్‌ను కలిగి ఉన్న వస్తువుల శ్రేణికి ఈ ఫంక్షన్‌ను ఎలా వర్తింపజేయవచ్చో ఇప్పుడు చూద్దాం, కింది విధంగా:

లెట్= [{'పేరు':'జాన్'},{'పేరు':'బాబ్'},{'పేరు':'ఇవాన్'}]


BOB అనే పదాన్ని అన్ని చిన్న అక్షరాలకు మార్చడానికి, మేము దానిని ఈ క్రింది విధంగా మారుస్తాము:

అరె[1].పేరు.దిగువ కేసు();


అద్భుతం. మీరు చూడగలిగినట్లుగా, జావాస్క్రిప్ట్ నుండి లోవర్‌కేస్ () ఫంక్షన్‌తో మేము చాలా చేయవచ్చు.

ముగింపు

ఈ వ్యాసంలో, స్ట్రింగ్ అక్షరాలను లోయర్-కేస్‌గా ఎలా మార్చాలో మేము మీకు చూపించాము. అదే ఫంక్షన్‌ను స్ట్రింగ్‌ల శ్రేణికి మరియు స్ట్రింగ్‌లను కలిగి ఉన్న వస్తువుల శ్రేణికి ఎలా వర్తింపజేయాలో కూడా మేము మీకు చూపించాము. అనధికారిక స్ట్రింగ్‌ను క్లీనర్‌గా మరియు మరింత అధికారికంగా కనిపించే చిన్న అక్షర స్ట్రింగ్‌గా మార్చడానికి ఈ కథనం ప్రయోజనకరంగా ఉందని నేను ఆశిస్తున్నాను. మీరు Linuxhint.com లో జావాస్క్రిప్ట్ గురించి మరింత తెలుసుకోవచ్చు.