జావాస్క్రిప్ట్‌లో సంక్లిష్ట కోడ్‌లతో వ్యవహరించేటప్పుడు, ఇన్‌లైన్ ఫంక్షన్ మరియు సాధారణ ఫంక్షన్ మధ్య వ్యత్యాసాన్ని గుర్తించడంలో తరచుగా అస్పష్టత ఉంటుంది. ఉదాహరణకు, రన్‌టైమ్‌లో సృష్టించబడిన వేరియబుల్ కోసం తనిఖీ చేయడం మరియు ఫంక్షన్‌కు కేటాయించడం. అటువంటి సందర్భాలలో, జావాస్క్రిప్ట్ ఉపయోగించి వేరియబుల్ ఫంక్షన్ రకంగా ఉందో లేదో తనిఖీ చేయడం డేటాను గుర్తించడంలో మరియు తగిన విధంగా క్రమబద్ధీకరించడంలో సహాయపడుతుంది.
జావాస్క్రిప్ట్‌లో వేరియబుల్ ఫంక్షన్ రకంగా ఉందో లేదో ధృవీకరించే విధానాలను ఈ బ్లాగ్ ప్రదర్శిస్తుంది.
జావాస్క్రిప్ట్‌లో వేరియబుల్ ఫంక్షన్ రకంగా ఉందో లేదో ఎలా తనిఖీ చేయాలి?
జావాస్క్రిప్ట్‌లో వేరియబుల్ ఫంక్షన్ రకంగా ఉందో లేదో తనిఖీ చేయడానికి/ధృవీకరించడానికి, కింది విధానాలను ఉపయోగించవచ్చు:
- 'టైప్ఆఫ్' ఆపరేటర్.
- 'ఉదాహరణ' ఆపరేటర్.
- “object.prototype.tostring.call()” పద్ధతి.
ఒక్కో విధానాన్ని ఒక్కొక్కటిగా పాటిద్దాం!
విధానం 1: టైప్ఆఫ్ ఆపరేటర్‌ని ఉపయోగించి జావాస్క్రిప్ట్‌లో వేరియబుల్ ఫంక్షన్ రకంగా ఉందో లేదో తనిఖీ చేయండి
ది ' రకం ” ఆపరేటర్ వేరియబుల్ యొక్క డేటా రకాన్ని పొందుతుంది. ఈ ఆపరేటర్ దాని రకం కోసం నిర్దిష్ట వేరియబుల్‌పై చెక్‌ను వర్తింపజేయడానికి కఠినమైన సమాన ఆపరేటర్ (===)తో కలిపి ఉపయోగించవచ్చు.
ఉదాహరణ
కింది ఉదాహరణను పరిశీలిద్దాం:
< స్క్రిప్ట్ రకం = 'టెక్స్ట్/జావాస్క్రిప్ట్' >ఫంక్షన్ గుణించాలి ( a , బి ) {
తిరిగి a * బి ;
}
ఉంటే ( రకం గుణించాలి === 'ఫంక్షన్' ) {
కన్సోల్. లాగ్ ( 'వేరియబుల్ ఫంక్షన్ రకం' ) ;
}
లేకపోతే {
కన్సోల్. లాగ్ ( 'వేరియబుల్ ఫంక్షన్ రకం కాదు' ) ;
}
స్క్రిప్ట్ >
పై కోడ్‌లో ఇచ్చిన విధంగా క్రింది దశల ద్వారా వెళ్దాం:
- ' అనే ఫంక్షన్‌ను ప్రకటించండి గుణించడం () ”రెండు సంఖ్యలను గుణించడం కోసం పేర్కొన్న పారామితులను కలిగి ఉంటుంది.
- దాని నిర్వచనంలో, ఫంక్షన్ యొక్క పారామితులుగా ఆమోదించబడిన పేర్కొన్న సంఖ్యలను గుణించండి.
- ఆ తరువాత, వర్తించు ' రకం 'ప్రకటిత వేరియబుల్ రకం కాదా అని ధృవీకరించడానికి కఠినమైన సమాన ఆపరేటర్ సహాయంతో ఆపరేటర్' ఫంక్షన్ ”.
- ఫలితంగా, సంబంధిత సందేశం వరుసగా సంతృప్తి లేదా సంతృప్తి చెందని స్థితిలో ప్రదర్శించబడుతుంది.
అవుట్‌పుట్
పై అవుట్‌పుట్‌లో, వేరియబుల్ “ గుణించాలి ” అనేది ఫంక్షన్ రకానికి చెందినది.
విధానం 2: ఆపరేటర్ యొక్క ఉదాహరణను ఉపయోగించి జావాస్క్రిప్ట్‌లో వేరియబుల్ ఫంక్షన్ రకంగా ఉందో లేదో తనిఖీ చేయండి
ది ' ఉదాహరణ రన్ టైమ్‌లో నిర్దిష్ట ఫంక్షన్, వేరియబుల్ మొదలైన వాటి రకాన్ని తనిఖీ చేయడానికి ఆపరేటర్ ఉపయోగించబడుతుంది. ఈ ఆపరేటర్ దాని సంబంధిత రకాన్ని పేర్కొనడం ద్వారా మరియు దానిపై చెక్‌ను వర్తింపజేయడం ద్వారా దాని రకానికి పాస్ చేసిన పరామితిని తనిఖీ చేయడానికి ఉపయోగించుకోవచ్చు.
వాక్యనిర్మాణం
పేరు ఉదాహరణ టైప్ చేయండిపై వాక్యనిర్మాణంలో:
- ' పేరు ” అనేది వేరియబుల్/ఫంక్షన్ పేరును సూచిస్తుంది.
- ' టైప్ చేయండి ” అనేది వేరియబుల్/ఫంక్షన్ రకానికి అనుగుణంగా ఉంటుంది, అనగా స్ట్రింగ్ మొదలైనవి.
ఉదాహరణ
దిగువ ఇవ్వబడిన ఉదాహరణ పేర్కొన్న భావనను వివరిస్తుంది:
< స్క్రిప్ట్ రకం = 'టెక్స్ట్/జావాస్క్రిప్ట్' >నమూనాFuncని అనుమతించండి = ఫంక్షన్ ( ) {
}
ఫంక్షన్ ఫంక్షన్ ధృవీకరించండి ( x ) {
ఉంటే ( x ఉదాహరణ ఫంక్షన్ ) {
అప్రమత్తం ( 'వేరియబుల్ ఫంక్షన్ రకం' ) ;
}
లేకపోతే {
అప్రమత్తం ( 'వేరియబుల్ ఫంక్షన్ రకం కాదు' ) ;
} }
ఫంక్షన్ ధృవీకరించండి ( నమూనా ఫంక్ ) ;
స్క్రిప్ట్ >
పై కోడ్ స్నిప్పెట్‌లో:
- ముందుగా, '' అనే ఇన్‌లైన్ ఫంక్షన్‌ను నిర్వచించండి నమూనాఫంక్() ”.
- ఆ తర్వాత, '' పేరుతో మరొక ఫంక్షన్‌ని ప్రకటించండి వెరిఫై ఫంక్షన్() ” పేర్కొన్న పరామితిని కలిగి ఉంది. దాని నిర్వచనంలో, “ని వర్తింపజేయండి ఉదాహరణ 'లో ఆపరేటర్' ఒకవేళ/లేకపోతే 'పరిస్థితి. ఇక్కడ, ' x ” ఆమోదించబడిన పరామితి పేరును సూచిస్తుంది మరియు “ ఫంక్షన్ ” వరుసగా దాని రకాన్ని సూచిస్తుంది.
- చివరగా, ఇన్‌లైన్ ఫంక్షన్‌ను దాని పారామీటర్‌గా పాస్ చేయడం ద్వారా పేర్కొన్న ఫంక్షన్‌ను యాక్సెస్ చేయండి. ఇది ఫలితంగా ఆపరేటర్‌లో పేర్కొన్న రకానికి సంబంధించి సంబంధిత సందేశాన్ని ప్రదర్శిస్తుంది.
అవుట్‌పుట్
పై అవుట్‌పుట్ నుండి, పేర్కొన్న ఇన్‌లైన్ ఫంక్షన్ '' అని గమనించవచ్చు. ఫంక్షన్ ” రకం.
విధానం 3: object.prototype.tostring.call() పద్ధతిని ఉపయోగించి జావాస్క్రిప్ట్‌లో వేరియబుల్ టైప్ ఫంక్షన్‌కి చెందినదా అని తనిఖీ చేయండి/ధృవీకరించండి
ది ' Object.prototype.toString() వస్తువును సూచించగల స్ట్రింగ్‌ను తిరిగి ఇవ్వడానికి ” పద్ధతి ఉపయోగించబడుతుంది. ఈ పద్ధతిని ఆబ్జెక్ట్ యొక్క పద్ధతి సహాయంతో అన్వయించవచ్చు, అంటే వస్తువు రకం తిరిగి వస్తుంది.
ఉదాహరణ
కింది ఉదాహరణను స్థూలంగా పరిశీలిద్దాం:
< స్క్రిప్ట్ రకం = 'టెక్స్ట్/జావాస్క్రిప్ట్' >నమూనాFuncని అనుమతించండి = ఫంక్షన్ ( ) { }
ఫంక్షన్ ఫంక్షన్ ధృవీకరించండి ( x ) {
ఉంటే ( వస్తువు . నమూనా . స్ట్రింగ్ . కాల్ చేయండి ( x ) == '[ఆబ్జెక్ట్ ఫంక్షన్]' ) {
కన్సోల్. లాగ్ ( 'వేరియబుల్ ఫంక్షన్ రకం' ) ;
}
లేకపోతే {
కన్సోల్. లాగ్ ( 'వేరియబుల్ ఫంక్షన్ రకం కాదు' ) ;
} }
ఫంక్షన్ ధృవీకరించండి ( నమూనా ఫంక్ ) ;
స్క్రిప్ట్ >
పైన పేర్కొన్న కోడ్ లైన్లలో పేర్కొన్న విధంగా క్రింది దశలను అమలు చేయండి:
- అదేవిధంగా, '' పేరుతో ఒక ఇన్‌లైన్ ఫంక్షన్‌ను ప్రకటించండి నమూనాఫంక్() ”.
- తదుపరి దశలో, '' అనే ఫంక్షన్‌ను నిర్వచించండి వెరిఫై ఫంక్షన్() ” పేర్కొన్న పరామితిని కలిగి ఉంది.
- దాని నిర్వచనంలో, “ని వర్తింపజేయండి Object.prototype.toString.call() ” ఫంక్షన్ యొక్క పారామీటర్‌ను సూచించడం ద్వారా పద్ధతి. ది ' ఫంక్షన్ ” ఇక్కడ తనిఖీ చేయవలసిన నిర్దిష్ట ఫంక్షన్ రకాన్ని సూచిస్తుంది.
- జోడించబడింది ' ఉంటే ఆమోదించబడిన పరామితి ఒక ఫంక్షన్ అయితే షరతు అమలు అవుతుంది.
- మరొక సందర్భంలో, ' లేకపోతే ” షరతు అమలు చేయబడుతుంది.
అవుట్‌పుట్
పై అవుట్‌పుట్ అవసరమైన కార్యాచరణను సాధించిందని సూచిస్తుంది.
ముగింపు
ది ' రకం 'ఆపరేటర్, ది' ఉదాహరణ 'ఆపరేటర్, లేదా' object.prototype.tostring.call() ”పద్ధతి జావాస్క్రిప్ట్‌లో వేరియబుల్ ఫంక్షన్ రకంగా ఉందో లేదో తనిఖీ చేయవచ్చు/ధృవీకరించవచ్చు. వేరియబుల్ రకాన్ని తనిఖీ చేయడానికి టైప్ఆఫ్ ఆపరేటర్‌ను కఠినమైన సమాన ఆపరేటర్‌తో కలపవచ్చు. ఆపరేటర్ యొక్క ఉదాహరణ దాని సంబంధిత రకాన్ని పేర్కొనడం ద్వారా మరియు దానిపై చెక్‌ను వర్తింపజేయడం ద్వారా పాస్ అయిన వేరియబుల్ కోసం తనిఖీ చేస్తుంది. object.prototype.tostring.call() పద్ధతి ఆబ్జెక్ట్ రకాన్ని అందిస్తుంది. జావాస్క్రిప్ట్‌ని ఉపయోగించి వేరియబుల్ ఫంక్షన్ రకానికి చెందినదా కాదా అని ధృవీకరించే పద్ధతులను ఈ రైట్-అప్ అందించింది.