ఈ రోజు మనం వెలుగులోకి వస్తాము ' జావాస్క్రిప్ట్‌లో సంఖ్యను ఎలా వర్గీకరించాలి '. దయచేసి ఒక వేరియబుల్‌కు కేటాయించిన స్థిరాంకం వలె నంబర్ అందించబడవచ్చని లేదా ఫారమ్‌ని ఉపయోగించి డైనమిక్‌గా అందించబడవచ్చని గుర్తుంచుకోండి.
సానుకూల లేదా ప్రతికూల సంఖ్యతో సంబంధం లేకుండా ఏదైనా సంఖ్యను వర్గీకరించడానికి మేము సాధారణ JavaScript ప్రోగ్రామ్‌ను వ్రాస్తాము. మొదలు పెడదాం.
జావాస్క్రిప్ట్ ప్రోగ్రామ్ యొక్క ప్రాథమిక వాక్యనిర్మాణాన్ని వ్రాయడం మొదటి దశ. జావాస్క్రిప్ట్ సాధారణంగా HTML పత్రం యొక్క హెడ్ ట్యాగ్ లోపల ఉంటుంది.
జావాస్క్రిప్ట్ సింటాక్స్
కాబట్టి, మేము దానిని శరీరానికి బదులుగా హెడ్ ట్యాగ్ లోపల ఉపయోగిస్తాము. జావాస్క్రిప్ట్ a తో ప్రారంభమవుతుంది <స్క్రిప్ట్> ట్యాగ్ చేసి ముగుస్తుంది ట్యాగ్. ప్రాథమిక వాక్యనిర్మాణం క్రింద ఇవ్వబడింది.
<html> <head> <script> ........................... </script> </head> <body> </body> </html>
జావాస్క్రిప్ట్‌లో సంఖ్యను వర్గీకరించడానికి ఒక ఫంక్షన్‌ను సృష్టించండి
మనం నేరుగా లోపల ఒక స్క్వేర్ పెర్ఫార్మింగ్ కోడ్‌ని వ్రాయవచ్చు స్క్రిప్ట్ ట్యాగ్, కానీ ఒక సృష్టించడానికి ఉత్తమం ఫంక్షన్ మరియు మళ్లీ ఉపయోగించేందుకు లోపల కోడ్ రాయండి.
ఫంక్షన్ పేరుతో విజయవంతం అయిన ఫంక్షన్‌తో జావాస్క్రిప్ట్ ఫంక్షన్ ప్రకటించబడింది. JS ఫంక్షన్ యొక్క సాధారణ వాక్యనిర్మాణం క్రింది విధంగా కనిపిస్తుంది:
function functionName(parameter1, parameter2)
{
function body;
}
బ్లడ్ మూన్ జూలై 12
మనం స్క్వేర్ ఫంక్షన్‌ని వ్రాస్తే, అది దీనితో ప్రారంభమవుతుంది కీవర్డ్ 'ఫంక్షన్', మరియు దాని పేరు ఏదైనా కావచ్చు, కానీ స్వీయ వివరణాత్మక పేర్లను ఉపయోగించడం ఉత్తమం మరియు మేము పేరును ఉపయోగిస్తాము ' చతురస్రం'.
function Square(parameter1, parameter2)
{
function body;
}
లీగ్ ఆఫ్ లెజెండ్స్ డ్రాగన్ మార్పులు
ప్రాథమిక సింటాక్స్ లోపల, మేము రెండు పారామితులను ఇచ్చాము మరియు అవసరాన్ని బట్టి ఇవి ఏదైనా సంఖ్య కావచ్చు.
పరామితులు ఫంక్షన్‌కి పంపబడిన విలువలు వాటిపై పని చేయడానికి మరియు గణన తర్వాత ఫలితాన్ని తిరిగి ఇవ్వడానికి.
అయితే, మా లక్ష్యం ఒక పరామితిని అంగీకరించి, ఇచ్చిన సంఖ్య యొక్క స్క్వేర్డ్ విలువను అందించే ఫంక్షన్‌ని సృష్టించడం.
మన నిజ జీవిత ఉదాహరణ నుండి దానిని అర్థం చేసుకోవడానికి ప్రయత్నిస్తే, అది మనకు మరింత సరళంగా ఉంటుంది. మేము సంఖ్య యొక్క వర్గాన్ని లెక్కించాలనుకుంటున్నాము.
గణన కోసం ఏమి అందించాలి? సంఖ్య తప్ప మరేమీ లేదు. ఒక ఫంక్షన్‌ని కూడా ఒక యంత్రంగా భావించవచ్చు, ఇది ఏదైనా తీసుకుంటుంది, దానిని ప్రాసెస్ చేస్తుంది మరియు ఏదైనా అవుట్‌పుట్ చేస్తుంది.
ఈ సందర్భంలో, ఫంక్షన్ పడుతుంది ఒక సంఖ్య ఇన్‌పుట్‌గా, ప్రాసెస్ చేసి, అవుట్‌పుట్ చేయండి స్క్వేర్డ్ సంఖ్య. కాబట్టి, మా ఫంక్షన్ కోసం పరామితిని వ్రాసిన తర్వాత, ఫంక్షన్ ఇలా ఉంటుంది:
function Square(number)
{
function body;
}
ఇప్పుడు, కీవర్డ్ ఫంక్షన్ కోడ్ యొక్క ఈ భాగం ఒక ఫంక్షన్ అని జావాస్క్రిప్ట్‌కి చెబుతుంది. ఆ పదం చతురస్రం మేము ఈ ఫంక్షన్ కోసం ఎంచుకున్న ఫంక్షన్ పేరు, మరియు ఇది ఏదైనా మంచి స్వీయ-వివరణాత్మకమైనది కావచ్చు.
కుండలీకరణ భాగం ద్వారా సూచించబడుతుంది () ప్రాసెస్ ఫంక్షన్‌కి మనం ఇచ్చే విలువను జతచేస్తుంది మరియు మేము దానికి పేరు కూడా పెట్టాము. దీనిని ఎ వేరియబుల్ ఎందుకంటే ఇది విభిన్న విలువలను కలిగి ఉంటుంది.
ఇక్కడ మనం వేరియబుల్‌కి a అని పేరు పెట్టాము సంఖ్య ఇది స్వీయ-వివరణాత్మకమైనది కాబట్టి; లేకపోతే, అది ఏదైనా కలిగి ఉండవచ్చు. ఆ తరువాత, మాకు కలుపులు ఉన్నాయి ద్వారా సూచించబడుతుంది {} ; ఇవి కేవలం ఫంక్షన్ యొక్క శరీరాన్ని చుట్టుముట్టాయి.
శరీరము e ఫంక్షన్ అనేది ఇచ్చిన విలువపై ప్రాసెసింగ్ చేసే కోడ్ మాత్రమే. ఇప్పటివరకు, మేము JS ఫంక్షన్‌లోని అన్ని భాగాలను చర్చించాము మరియు ఇప్పుడు మేము ఫంక్షన్ యొక్క బాడీని వివరంగా నేర్చుకోబోతున్నాము.
స్క్వేర్ చేయడం కోసం మనకు ఒక సంఖ్య వచ్చినప్పుడు, మనం యంత్రం లాంటి కాలిక్యులేటర్‌కి నంబర్ ఇచ్చినప్పుడు మనం ఏమి చేయాలి లేదా ఊహించాలి?
అది ఏమి చేయాలి? కాలిక్యులేటర్ వినియోగదారు నుండి ఇన్‌పుట్‌ను తీసుకుంటుంది మరియు సమాన సంతకం బటన్‌ను నొక్కిన వెంటనే విలువను అందిస్తుంది.
ఇక్కడ, మేము జావాస్క్రిప్ట్ భాషను ఉపయోగించి అదే పనిని చేస్తాము. జావాస్క్రిప్ట్ ఫంక్షన్ ప్రారంభమైనప్పుడు మనకు ఏమి ఉందో చూద్దాం. ఫంక్షన్ ప్రారంభంలో, కంపైలర్ కోడ్‌ను చదివినప్పుడు.
అని మనకు ఇప్పటికే తెలుసు ఫంక్షన్ కీవర్డ్ ఈ కోడ్ ముక్క ఫంక్షన్ పేరు మరియు తర్వాత సంఖ్య ద్వారా విజయవంతం అయిన ఫంక్షన్ అని తెలియజేస్తుంది కుండలీకరణంలో పని చేయాలి మరియు చివరగా, బ్రేస్‌లలో కోడ్ యొక్క బాడీ .
కంపైలర్ ఏమి చేస్తుంది
కంపైలర్ కోడ్‌ను చదవడం ప్రారంభించినప్పుడు, అది మొదటి కర్లీ బ్రేస్‌ను పొందుతుంది, ఆపై అది వేరియబుల్ లోపల నిల్వ చేయబడిన సంఖ్యను కనుగొంది సంఖ్య పని చేయడానికి.
సంఖ్యను ఎలా వర్గీకరించాలి
కాసేపు ప్రోగ్రామింగ్‌ను విస్మరించి, సంఖ్య లేదా స్క్వేర్ మీన్‌ని ఎలా వర్గీకరించవచ్చు అనే దాని గురించి ఆలోచించండి? ఒక సంఖ్యను సంఖ్యతో గుణించినప్పుడు, ఒక చదరపు విలువ ఉత్పత్తి అవుతుంది.
క్రిస్మస్ పాటలు జోస్ మారి చాన్
కాబట్టి, మనం చెప్పడం ద్వారా దానిని నిర్వచించవచ్చు సంఖ్య యొక్క వర్గము = సంఖ్య అదే సంఖ్యతో గుణించబడుతుంది .
జావాస్క్రిప్ట్‌లో గుణించడం ఎలా
అందువల్ల, జావాస్క్రిప్ట్ గుర్తుతో గుణకారాన్ని సూచిస్తుంది * కాబట్టి పై ప్రకటన ఇలా ఉంటుంది సంఖ్య యొక్క వర్గము = సంఖ్య * సంఖ్య .
ఇక్కడ, ది = గుర్తును అసైన్‌మెంట్ ఆపరేటర్ అని పిలుస్తారు మరియు అది ఒకే స్థిరమైన విలువ, వేరియబుల్ లేదా వ్యక్తీకరణ అయినా కుడి నుండి ఎడమ వైపున ఉన్న విలువను కేటాయించబడుతుంది.
వ్యక్తీకరణ మొదట మూల్యాంకనం చేయబడుతుంది, ఆపై అది ఎడమ వైపున ఉన్న వేరియబుల్‌కు కేటాయించబడుతుంది. సంఖ్యను వర్గీకరించడం అనే ప్రాథమిక భావనను ఇప్పుడు మనం అర్థం చేసుకున్నామని నేను ఆశిస్తున్నాను మరియు ఇప్పుడు మనం దానిని జావాస్క్రిప్ట్‌లో అమలు చేయవచ్చు. కోడ్ ఇలా ఉంటుంది:
function Square(number)
{
var Square;
Square = number * number;
return Square;
}
జావాస్క్రిప్ట్ సింటాక్స్‌ను ఎలా సరళీకరించాలి
పై స్నిప్పెట్‌ని సరళీకృతం చేద్దాం. మేము లైన్ నుండి ఏమి చేసాము స్క్వేర్ ఉంది; మేము వాస్తవానికి కావలసిన సంఖ్య యొక్క వర్గాన్ని నిల్వ చేయడానికి ఒక వేరియబుల్‌ని ప్రకటించాము.
అప్పుడు మేము చతురస్రాన్ని కేటాయించాము ప్రకటనను ఉపయోగించడం ద్వారా దానికి చదరపు = సంఖ్య * సంఖ్య; దయచేసి ప్రతి జావాస్క్రిప్ట్ స్టేట్‌మెంట్ సెమికోలన్‌తో ముగుస్తుందని గమనించండి.
చివరి పంక్తిలో ఒక ప్రశ్న లేవనెత్తవచ్చు. ఉపయోగించడం యొక్క ప్రయోజనం ఏమిటి రిటర్న్ స్క్వేర్; ? మేము నిల్వ చేసిన విలువను తిరిగి ఇస్తున్నాము చతురస్రం ఫంక్షన్ నుండి వేరియబుల్.
ఇది మనం యంత్రానికి ఏదైనా ఇచ్చినట్లే, మరియు యంత్రాలు వేరొక రూపంలో తిరిగి ఇస్తాయి. మేము ఒక గ్రౌండింగ్ యంత్రం కోసం గింజలు అందించడానికి వంటి, మరియు అది మాకు ఒక పిండి అందిస్తుంది.
ఇక్కడ ధాన్యాలు వేరియబుల్ సంఖ్య మేము ఫంక్షన్‌కు ఇస్తాము మరియు అది వేరియబుల్‌లో నిల్వ చేసిన విలువను తిరిగి ఇస్తుంది చతురస్రం, ఇది ఇచ్చిన సంఖ్య యొక్క వర్గము. HTML కోడ్ లోపల పూర్తి ప్రోగ్రామ్‌ని చూద్దాం.
జోయెల్ డి లా ఫ్యూయెంటే జాతి
<html>
<head>
<script>
function Square(number)
{
var Square;
Square = number * number;
return Square;
}
document.getElementById("square").innerHTML = Square(4);
</script>
</head>
<body>
<p id ="square"></p>
</body>
</html>
document.getElementById(“స్క్వేర్”).innerHTML = స్క్వేర్(4); , ఈ లైన్ వాస్తవానికి HTML మూలకాన్ని సూచిస్తుంది Id 'స్క్వేర్' మరియు దాని కంటెంట్‌లను ఫంక్షన్ ఫలితానికి మార్చడం.
ఈ స్థితిలో, మేము ఇప్పటికీ మా బ్రౌజర్‌లో మార్పులను పొందలేము ఎందుకంటే మేము హెడ్‌లో ఫంక్షన్‌ను ప్రకటించాము, కానీ మేము HTML ట్యాగ్ యొక్క కంటెంట్‌ను మార్చడానికి ప్రయత్నిస్తున్నాము శరీరంలో.
బ్రౌజర్ కోడ్‌ను ఎడమ నుండి కుడికి మరియు పై నుండి క్రిందికి చదువుతుంది కాబట్టి అది లైన్‌ను చదివినప్పుడు document.getElementById(“స్క్వేర్”).innerHTML = స్క్వేర్(4); దానికి ఐడితో ఉన్న ట్యాగ్ గురించి తెలియదు 'చదరపు' .
జావాస్క్రిప్ట్ భాగాన్ని