టైప్‌స్క్రిప్ట్ అనుకూల రకాలకు మద్దతు ఇస్తుంది, వీటిని ''ని ఉపయోగించి నిర్వచించవచ్చు ఇంటర్ఫేస్ 'లేదా' రకం ”. ఇంటర్‌ఫేస్‌ను క్లాస్ లేదా ఆబ్జెక్ట్ ద్వారా అమలు చేయవచ్చు, అయితే టైప్ అలియాస్ ఇప్పటికే ఉన్న రకానికి కొత్త పేరును సృష్టించడానికి లేదా రకాల యూనియన్‌ను నిర్వచించడానికి మాత్రమే ఉపయోగించబడుతుంది. రకాలు మరియు ఇంటర్‌ఫేస్‌లు తరచుగా పరస్పరం మార్చుకోగలిగినప్పటికీ, వాటి ఫంక్షనాలిటీ మరియు సింటాక్స్‌లో కొన్ని తేడాలు ఉన్నాయి, ఇవి వాటిని నిర్దిష్ట దృశ్యాలకు మరింత సముచితంగా చేస్తాయి.
ఈ బ్లాగ్ టైప్‌స్క్రిప్ట్ ఇంటర్ఫేస్ మరియు రకం మరియు వాటి తేడాను వివరిస్తుంది.
టైప్‌స్క్రిప్ట్ ఇంటర్ఫేస్ vs టైప్ అంటే ఏమిటి?
' ఇంటర్ఫేస్ 'మరియు' రకం ” టైప్‌స్క్రిప్ట్‌లో అనుకూల రకాలను నిర్వచించడానికి ఉపయోగించబడతాయి. కానీ వాటి కార్యాచరణ మరియు వాక్యనిర్మాణంలో కొన్ని వ్యత్యాసాలు ఉన్నాయి. ఇంటర్ఫేస్ మరియు రకానికి మధ్య ఉన్న ప్రధాన వ్యత్యాసం ఏమిటంటే, ఇంటర్ఫేస్ కొత్త రకాన్ని నిర్వచిస్తుంది, అయితే టైప్ అలియాస్ నిర్వచించదు.
ఇంటర్‌ఫేస్‌ను క్లాస్ లేదా ఆబ్జెక్ట్ ద్వారా అమలు చేయవచ్చు, అయితే రకాలు యూనియన్‌లు మరియు ఖండనల వంటి లక్షణాలను ఉపయోగించి మరింత సంక్లిష్ట రకాలను నిర్వచించవచ్చు. సాధారణంగా, ఇంటర్‌ఫేస్‌లు ఆబ్జెక్ట్ ఆకారాలు మరియు APIలను నిర్వచించడానికి సాధారణంగా ఉపయోగించబడతాయి, అయితే సంక్లిష్ట డేటా రకాలు మరియు యుటిలిటీ రకాలను నిర్వచించడానికి రకాలు ఎక్కువగా ఉపయోగించబడతాయి. ఈ రెండింటినీ విడిగా అర్థం చేసుకుందాం.
టైప్‌స్క్రిప్ట్ ఇంటర్ఫేస్ అంటే ఏమిటి?
టైప్‌స్క్రిప్ట్ ఇంటర్ఫేస్ అనేది టైప్‌స్క్రిప్ట్ వస్తువు యొక్క ఆకారాన్ని నిర్వచించే సాంకేతికత. ఇది కీవర్డ్ ఉపయోగించి సృష్టించబడింది ' ఇంటర్ఫేస్ ” మరియు ఇది ఒక వస్తువును ఆ రకంగా వర్గీకరించడానికి అవసరమైన గుణాలు మరియు పద్ధతుల సమితిని నిర్దేశిస్తుంది. ఇది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో తరగతికి సమానం; అయితే, ఇది ఏ అమలును నిర్వచించలేదు. ఇంటర్‌ఫేస్‌లు ప్రధానంగా టైప్ చెకింగ్ మరియు ఆబ్జెక్ట్ నిర్దిష్ట నిర్మాణానికి అనుగుణంగా ఉండేలా చూసుకోవడానికి ఉపయోగించబడతాయి.
కొనసాగడానికి ముందు, టైప్‌స్క్రిప్ట్ ఫైల్‌ను అమలు చేయడానికి, అది తప్పనిసరిగా జావాస్క్రిప్ట్ ఫైల్‌లోకి ట్రాన్స్‌పైల్ చేయబడి, ఆపై ఇచ్చిన ఆదేశాలను ఉపయోగించి టెర్మినల్‌లో జావాస్క్రిప్ట్ కోడ్‌ను అమలు చేయాలని గుర్తుంచుకోండి:
tsc filename.tsనోడ్ filename.js
ఉదాహరణ
'యూజర్' అనే ఇంటర్‌ఫేస్‌ను సృష్టించండి, అది మూడు లక్షణాలను మరియు ఒక పద్ధతిని నిర్వచిస్తుంది ' getInfo() ”:
ఇంటర్ఫేస్ వినియోగదారు {మొదటి పేరు: స్ట్రింగ్;
చివరి పేరు: స్ట్రింగ్;
వయస్సు: సంఖ్య;
సమాచారం పొందండి ( ) : శూన్యం;
}
తరగతిని సృష్టించండి' విద్యార్థి ” అది ఇంటర్‌ఫేస్‌తో వారసత్వంగా వస్తుంది. తరగతి దాని లక్షణాలను నిర్వచిస్తుంది, గుణాలకు విలువలను కేటాయించే కన్స్ట్రక్టర్ మరియు లక్షణాలకు సంబంధించి విలువలను ప్రదర్శించే “getInfo()” పద్ధతి:
మొదటి పేరు: స్ట్రింగ్;
చివరి పేరు: స్ట్రింగ్;
వయస్సు: సంఖ్య;
నిర్మాణకర్త ( మొదటి పేరు: స్ట్రింగ్, చివరి పేరు: స్ట్రింగ్, వయస్సు: సంఖ్య ) {
this.firstName = మొదటి పేరు;
this.lastName = చివరి పేరు;
ఈ.వయస్సు = వయస్సు;
}
సమాచారం పొందండి ( ) : శూన్యం {
console.log ( 'విద్యార్థి సమాచారం:' )
console.log ( '- పేరు:' + this.firstName + '' + this.lastName ) ;
console.log ( '- వయస్సు:' + ఈ వయస్సు ) ;
}
}
ఒక వస్తువును సృష్టించండి ' విద్యార్థి ' అనే ' std 'యొక్క' వినియోగదారు 'కొత్త' కీవర్డ్‌తో కన్‌స్ట్రక్టర్‌ను కాల్ చేయడం ద్వారా టైప్ చేసి, ఆపై, కన్సోల్‌లో డేటాను ప్రింట్ చేయడానికి getInfo() పద్ధతికి కాల్ చేయండి:
std.getInfo ( ) ;
అవుట్‌పుట్
టైప్‌స్క్రిప్ట్ రకం అంటే ఏమిటి?
టైప్‌స్క్రిప్ట్ రకాలు ఎక్కువగా ఇప్పటికే ఉన్న రకాలకు మారుపేర్లను సృష్టించడానికి అలాగే మరింత సంక్లిష్టమైన రకాలను రూపొందించడానికి ఉపయోగించబడతాయి. ఇది నిర్దిష్ట ఆకృతి లేదా డేటా నిర్మాణాన్ని సూచిస్తుంది. దీనిని 'తో నిర్వచించవచ్చు/ప్రకటించవచ్చు రకం ” కీవర్డ్. కోడ్‌ను మరింత అర్థమయ్యేలా చేయడానికి మరియు పునరావృతం/నకిలీని తగ్గించడానికి టైప్‌స్క్రిప్ట్ రకాలను ఉపయోగించవచ్చు.
ఉదాహరణ
ముందుగా, ఒక రకాన్ని నిర్వచించండి ' వినియోగదారు 'ఉపయోగించి' రకం 'ఐదు లక్షణాలతో పేర్కొన్న కీవర్డ్ వాటిలో ఒకటి ఐచ్ఛిక లక్షణం, అది ' ఫోన్ ”:
రకం వాడుకరి = {మొదటి పేరు: స్ట్రింగ్;
చివరి పేరు: స్ట్రింగ్;
వయస్సు: సంఖ్య;
ఇమెయిల్: స్ట్రింగ్;
ఫోన్?: స్ట్రింగ్;
} ;
' అనే ఫంక్షన్‌ను నిర్వచించండి getFullName ', ఇది రకం పరామితిని తీసుకుంటుంది' వినియోగదారు 'మరియు' సహా వ్యక్తి యొక్క సమాచారాన్ని కలిగి ఉన్న డేటాను ప్రింట్ చేస్తుంది పేరు ',' వయస్సు ',' ఇమెయిల్ 'మరియు' ఫోను నంబరు ”:
console.log ( 'వినియోగదారు సమాచారం:' )
console.log ( '- పేరు:' + person.firstName + '' + వ్యక్తి.చివరి పేరు ) ;
console.log ( '- వయస్సు:' + వ్యక్తి.వయస్సు ) ;
console.log ( '- ఇమెయిల్:' + person.email ) ;
console.log ( '-ఫోన్ #:' + వ్యక్తి.ఫోన్ ) ;
}
ఇప్పుడు, ఒక వస్తువును సృష్టించండి ' వ్యక్తి 'రకం' వినియోగదారు 'కీ-విలువ జతలతో:
మొదటి పేరు: 'మిలీ' ,
చివరి పేరు: 'మైఖేల్' ,
వయస్సు: 28 ,
ఇమెయిల్: 'mili124@yahoo.com' ,
ఫోన్: '086-34581734'
} ;
చివరగా, ఫంక్షన్ getInfo()కు కాల్ చేయడం ద్వారా వినియోగదారు సమాచారాన్ని ముద్రించండి:
అవుట్‌పుట్
అదంతా టైప్‌స్క్రిప్ట్ ఇంటర్ఫేస్ మరియు రకం గురించి.
ముగింపు
టైప్‌స్క్రిప్ట్‌లో, ' ఇంటర్ఫేస్ 'మరియు' రకం ” అనేవి కస్టమ్ రకాలను నిర్వచించడానికి ఉపయోగించబడతాయి. ఇంటర్‌ఫేస్‌ని క్లాస్ లేదా ఆబ్జెక్ట్ ద్వారా అమలు చేయవచ్చు, అయితే రకాలు యూనియన్‌లు మరియు ఖండనల వంటి లక్షణాలను ఉపయోగించి మరింత సంక్లిష్ట రకాలను నిర్వచించవచ్చు. ఇవి మరింత వ్యవస్థీకృత మరియు స్కేలబుల్ కోడ్‌ను వ్రాయడంలో సహాయపడే శక్తివంతమైన లక్షణాలు. ఈ బ్లాగ్ టైప్‌స్క్రిప్ట్ ఇంటర్ఫేస్ మరియు రకం మరియు వాటి తేడాను వివరించింది.