టైప్‌స్క్రిప్ట్ ట్యుటోరియల్: టైప్‌స్క్రిప్ట్ యొక్క ఫండమెంటల్స్ గురించి తెలుసుకోండి

టైప్‌స్క్రిప్ట్ అనేది గట్టిగా టైప్ చేసిన సూపర్‌సెట్ ఇది సాదా జావాస్క్రిప్ట్‌కు కంపైల్ చేస్తుంది. అప్లికేషన్-స్కేల్ జావాస్క్రిప్ట్ అభివృద్ధి కోసం మీరు ఈ భాషను ఉపయోగించవచ్చు. అలాగే, ఇది ఏదైనా బ్రౌజర్, ఏదైనా హోస్ట్ మరియు ఏదైనా ఆపరేటింగ్ సిస్టమ్‌లో అమలు చేయవచ్చు. ఈ టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌లో, మేము టైప్‌స్క్రిప్ట్ యొక్క లోతులోకి ప్రవేశిస్తాము మరియు ఈ క్రింది క్రమంలో ప్రాథమికాలను అర్థం చేసుకుంటాము:

• టైప్‌స్క్రిప్ట్ పరిచయం
• టైప్‌స్క్రిప్ట్ రకాలు
• వేరియబుల్స్
• ఆపరేటర్లు
• ఉచ్చులు
• విధులు
• తీగలను
• శ్రేణులు
• ఇంటర్ఫేస్లు
• తరగతులు
• వస్తువులు
• టైప్‌స్క్రిప్ట్ యూజ్ కేస్

టైప్‌స్క్రిప్ట్ పరిచయం

టైప్‌స్క్రిప్ట్ అనేది జావాస్క్రిప్ట్ యొక్క టైప్ చేసిన సూపర్‌సెట్, ఇది సాదా జావాస్క్రిప్ట్‌కు కంపైల్ చేస్తుంది. టైప్‌స్క్రిప్ట్ అనేది తరగతులు, ఇంటర్‌ఫేస్‌లు మరియు స్థిరంగా టైప్ చేసిన ప్రోగ్రామింగ్ భాషలతో స్వచ్ఛమైన ఆబ్జెక్ట్-ఓరియెంటెడ్ సి # లేదా . జావాస్క్రిప్ట్ ఫైల్‌లో కంపైల్ చేయడానికి మరియు ఉత్పత్తి చేయడానికి కంపైలర్ అవసరం. సాధారణంగా, టైప్‌స్క్రిప్ట్ కొన్ని అదనపు లక్షణాలతో జావాస్క్రిప్ట్ యొక్క ES6 వెర్షన్.

టైప్‌స్క్రిప్ట్ కోడ్ ఉన్న ఫైల్‌లో వ్రాయబడుతుంది .ts పొడిగింపు ఆపై కంపైలర్ ఉపయోగించి జావాస్క్రిప్ట్‌లోకి కంపైల్ చేస్తారు. మీరు ఏదైనా కోడ్ ఎడిటర్‌లో ఫైల్‌ను వ్రాయవచ్చు మరియు మీ ప్లాట్‌ఫామ్‌లో కంపైలర్‌ను ఇన్‌స్టాల్ చేయాలి. సంస్థాపన తరువాత, ఆదేశం tsc .ts టైప్‌స్క్రిప్ట్ కోడ్‌ను సాదా జావాస్క్రిప్ట్ ఫైల్‌గా కంపైల్ చేస్తుంది.

సింటాక్స్:

var సందేశం: స్ట్రింగ్ = 'ఎడురేకాకు స్వాగతం!' console.log (సందేశం)

కంపైల్ చేసినప్పుడు, ఇది క్రింది జావాస్క్రిప్ట్ కోడ్‌ను ఉత్పత్తి చేస్తుంది:

// టైప్‌స్క్రిప్ట్ 1.8.10 var సందేశం ద్వారా రూపొందించబడింది = 'ఎడురేకాకు స్వాగతం!' console.log (సందేశం)

టైప్‌స్క్రిప్ట్ యొక్క లక్షణాలు

• క్రాస్ ప్లాట్‌ఫాం: విండోస్, మాకోస్ మరియు లైనక్స్ వంటి ఏదైనా ఆపరేటింగ్ సిస్టమ్‌లో టైప్‌స్క్రిప్ట్ కంపైలర్‌ను ఇన్‌స్టాల్ చేయవచ్చు.

  
  
  

• ఆబ్జెక్ట్ ఓరియెంటెడ్ లాంగ్వేజ్ : టైప్‌స్క్రిప్ట్ వంటి లక్షణాలను అందిస్తుంది తరగతులు , ఇంటర్‌ఫేస్‌లు మరియు గుణకాలు. అందువల్ల, ఇది క్లయింట్-సైడ్ మరియు సర్వర్-సైడ్ డెవలప్‌మెంట్ కోసం ఆబ్జెక్ట్-ఓరియెంటెడ్ కోడ్‌ను వ్రాయగలదు.

• స్టాటిక్ టైప్-చెకింగ్ : టైప్‌స్క్రిప్ట్ స్టాటిక్ టైపింగ్‌ను ఉపయోగిస్తుంది మరియు కంపైల్ సమయంలో టైప్ చెకింగ్‌కు సహాయపడుతుంది. అందువల్ల, స్క్రిప్ట్‌ను అమలు చేయకుండా కోడ్ రాసేటప్పుడు మీరు లోపాలను కనుగొనవచ్చు.

• ఐచ్ఛిక స్టాటిక్ టైపింగ్ : మీరు జావాస్క్రిప్ట్ యొక్క డైనమిక్ టైపింగ్ ఉపయోగిస్తుంటే టైప్‌స్క్రిప్ట్ ఐచ్ఛిక స్టాటిక్ టైపింగ్‌ను కూడా అనుమతిస్తుంది.

• DOM మానిప్యులేషన్ : మీరు అంశాలను జోడించడానికి లేదా తొలగించడానికి DOM ను మార్చటానికి టైప్‌స్క్రిప్ట్‌ని ఉపయోగించవచ్చు.

• ES 6 ఫీచర్స్ : టైప్‌స్క్రిప్ట్‌లో క్లాస్, ఇంటర్‌ఫేస్, బాణం ఫంక్షన్లు మొదలైన ప్రణాళికాబద్ధమైన ECMAScript 2015 (ES 6, 7) యొక్క చాలా లక్షణాలు ఉన్నాయి.

టైప్‌స్క్రిప్ట్ ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు

• టైప్‌స్క్రిప్ట్ వేగంగా, సరళంగా, నేర్చుకోవడం సులభం మరియు ఏదైనా బ్రౌజర్ లేదా జావాస్క్రిప్ట్ ఇంజిన్‌లో నడుస్తుంది.

• అది సారూప్యత కు జావాస్క్రిప్ట్ మరియు అదే వాక్యనిర్మాణం మరియు అర్థాలను ఉపయోగిస్తుంది.

• ఇది బ్యాకెండ్ డెవలపర్లు ఫ్రంట్ ఎండ్ రాయడానికి సహాయపడుతుంది కోడ్ వేగంగా .

• టైప్‌స్క్రిప్ట్ కోడ్‌ను ఒక నుండి పిలుస్తారు ఇప్పటికే ఉన్న జావాస్క్రిప్ట్ కోడ్ . అలాగే, ఇది ఇప్పటికే ఉన్న జావాస్క్రిప్ట్ ఫ్రేమ్‌వర్క్‌లు మరియు లైబ్రరీలతో ఎటువంటి సమస్యలు లేకుండా పనిచేస్తుంది.

• .D.ts పొడిగింపుతో డెఫినిషన్ ఫైల్, ఇప్పటికే ఉన్న జావాస్క్రిప్ట్ లైబ్రరీలకు మద్దతునిస్తుంది J క్వెరీ, D3.js , మొదలైనవి కాబట్టి, టైప్‌స్క్రిప్ట్ కోడ్ జోడించవచ్చు జావాస్క్రిప్ట్ లైబ్రరీలు ఇప్పటికే ఉన్న డైనమిక్‌గా టైప్ చేసిన జావాస్క్రిప్ట్ లైబ్రరీలలో టైప్-చెకింగ్, కోడ్ ఆటో కంప్లీషన్ మరియు డాక్యుమెంటేషన్ యొక్క ప్రయోజనాలను పొందడానికి టైప్ డెఫినిషన్స్‌ను ఉపయోగించడం.

• ఇది నుండి లక్షణాలను కలిగి ఉంటుంది ES6 మరియు ES7 ఇది ES5- స్థాయి జావాస్క్రిప్ట్ ఇంజిన్లలో అమలు చేయగలదు Node.js .

టైప్‌స్క్రిప్ట్ అంటే ఏమిటో ఇప్పుడు మీరు అర్థం చేసుకున్నారు, ఈ టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌తో ముందుకు సాగండి మరియు వివిధ రకాలను పరిశీలిద్దాం.

టైప్‌స్క్రిప్ట్ రకాలు

టైప్ సిస్టమ్ భాష మద్దతు ఉన్న వివిధ రకాల విలువలను సూచిస్తుంది. ఇది తనిఖీ చేస్తుంది చెల్లుబాటు సరఫరా చేసిన విలువలు వారు ప్రోగ్రామ్ ద్వారా నిల్వ చేయడానికి లేదా మార్చటానికి ముందు.

దీనిని రెండు రకాలుగా వర్గీకరించవచ్చు:

• అంతర్నిర్మిత : ఇందులో సంఖ్య, స్ట్రింగ్, బూలియన్, శూన్య, శూన్య మరియు నిర్వచించబడలేదు.
• వినియోగాదారునిచే నిర్వచించబడినది : ఇందులో ఎన్యూమరేషన్స్ (ఎన్యూమ్స్), క్లాసులు, ఇంటర్‌ఫేస్‌లు, శ్రేణులు మరియు టుపుల్ ఉన్నాయి.

ఇప్పుడు ఈ టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌తో ముందుకు సాగండి మరియు వేరియబుల్స్ గురించి మరింత అర్థం చేసుకోండి.

టైప్‌స్క్రిప్ట్ ట్యుటోరియల్: వేరియబుల్స్

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

టైప్‌స్క్రిప్ట్‌లో వేరియబుల్‌ను డిక్లేర్ చేసే టైప్ సింటాక్స్‌లో వేరియబుల్ పేరు తర్వాత పెద్దప్రేగు (:) ఉంటుంది, దాని రకం ఉంటుంది. జావాస్క్రిప్ట్ మాదిరిగానే, మేము దీనిని ఉపయోగిస్తాము var కీవర్డ్ వేరియబుల్ ప్రకటించడానికి.

మేము వేరియబుల్ డిక్లేర్ చేసినప్పుడు నాలుగు ఎంపికలు ఉన్నాయి:

var [ఐడెంటిఫైయర్]: [type-annotation] = విలువ

var [ఐడెంటిఫైయర్]: [రకం-ఉల్లేఖన]

var [ఐడెంటిఫైయర్] = విలువ

var [గుర్తించండి]

ఉదాహరణ:

var పేరు: స్ట్రింగ్ = 'డైసీ' var empid: number = 1001 console.log ('name' + name) console.log ('ఉద్యోగి ఐడి' + empid)

కంపైల్ చేసినప్పుడు, ఇది క్రింది జావాస్క్రిప్ట్ కోడ్‌ను ఉత్పత్తి చేస్తుంది:

// టైప్‌స్క్రిప్ట్ 1.8.10 var name = 'Daisy' var empid = 1001 console.log ('name' + name) console.log ('ఉద్యోగి ఐడి:' + empid)

అవుట్పుట్:

పేరు: డైసీ
ఉద్యోగి ఐడి: 1001

ఇప్పుడు మన టైప్‌స్క్రిప్ట్ ట్యుటోరియల్ యొక్క తదుపరి అంశానికి వెళ్దాం.

ఆపరేటర్లు

డేటాలో నిర్వహించబడే విధులను నిర్వచించడానికి ఆపరేటర్ ఉపయోగించబడుతుంది. ఆపరేటర్లు పనిచేసే డేటాను ఒపెరాండ్స్ అంటారు. వివిధ రకాలు ఉన్నాయి ఆపరేటర్లు టైప్‌స్క్రిప్ట్‌లో:

• అంకగణిత ఆపరేటర్లు
• లాజికల్ ఆపరేటర్లు
• రిలేషనల్ ఆపరేటర్లు
• బిట్‌వైస్ ఆపరేటర్లు
• అసైన్మెంట్ ఆపరేటర్లు

అంకగణిత ఆపరేటర్లు

ఉదాహరణ:

var num1: number = 10 var num2: number = 2 var res: number = 0 res = num1 + num2 console.log ('మొత్తం:' + res) res = num1 - num2 console.log ('తేడా:' + res) res = num1 * num2 console.log ('ఉత్పత్తి:' + res)

అవుట్పుట్:

మొత్తం: 12
తేడా: 8
ఉత్పత్తి: 20

లాజికల్ ఆపరేటర్లు

ఉదాహరణ:

var సగటు: సంఖ్య = 20 var శాతం: సంఖ్య = 90 కన్సోల్.లాగ్ ('సగటు విలువ:' + సగటు + ', శాతం విలువ:' + శాతం) var res: బూలియన్ = ((సగటు> 50) && (శాతం> 80 )) console.log ('(సగటు> 50) && (శాతం> 80):', రెస్)

అవుట్పుట్:

సగటు విలువ: 20, శాతం విలువ: 90
(సగటు> 50) && (శాతం> 80): తప్పుడు

రిలేషనల్ ఆపరేటర్లు

ఉదాహరణ:

var num1: number = 10 var num2: number = 7 console.log ('num1 యొక్క విలువ:' + num1) console.log ('num2 యొక్క విలువ:' + num2) var res = num1> num2 console.log ('num1 num2 కన్నా ఎక్కువ: '+ res) res = num1
 అవుట్పుట్: 
సంఖ్య 1: 10 యొక్క విలువ 
 సంఖ్య 2: 7 యొక్క విలువ 
 num1 కంటే num1 ఎక్కువ: నిజం 
 num1 కంటే num1 తక్కువ: తప్పుడు
 బిట్‌వైస్ ఆపరేటర్లు 
 ఆపరేటర్లు 
 వివరణ 
 బిట్‌వైస్ మరియు (&) 
దాని పూర్ణాంక వాదనల యొక్క ప్రతి బిట్‌లో బూలియన్ మరియు ఆపరేషన్ చేస్తుంది.
 బిట్‌వైస్ OR (|) 
ఇది దాని పూర్ణాంక వాదనల యొక్క ప్రతి బిట్‌లో బూలియన్ OR ఆపరేషన్ చేస్తుంది.
 బిట్‌వైస్ XOR (^) 
ఇది దాని పూర్ణాంక వాదనల యొక్క ప్రతి బిట్‌లో బూలియన్ ప్రత్యేకమైన లేదా ఆపరేషన్ చేస్తుంది.
 బిట్‌వైస్ కాదు (~) 
ఇది అనామక ఆపరేటర్ మరియు ఒపెరాండ్‌లోని అన్ని బిట్‌లను రివర్స్ చేయడం ద్వారా పనిచేస్తుంది.
 ఎడమ షిఫ్ట్ (<<) 
ఇది రెండవ ఒపెరాండ్‌లో పేర్కొన్న స్థలాల సంఖ్య ద్వారా దాని మొదటి ఒపెరాండ్‌లోని అన్ని బిట్‌లను ఎడమ వైపుకు కదిలిస్తుంది.
 కుడి షిఫ్ట్ (>>) 
ఎడమ ఒపెరాండ్ యొక్క విలువ కుడి ఒపెరాండ్ పేర్కొన్న బిట్ల సంఖ్య ద్వారా కుడివైపుకి కదులుతుంది.
 సున్నాతో కుడి షిఫ్ట్ (>>>) 
ఇది >> ఆపరేటర్‌తో సమానంగా ఉంటుంది, ఎడమ వైపున మార్చబడిన బిట్స్ ఎల్లప్పుడూ సున్నాగా ఉంటాయి.
 ఉదాహరణ: 
var a: number = 2 // బిట్ ప్రదర్శన 10 var b: number = 3 // బిట్ ప్రెజెంటేషన్ 11 var result result = (a & b) console.log ('(a & b) =>', ఫలితం) result = ( a | బి) console.log ('(a | b) =>', ఫలితం)
 అవుట్పుట్: 
(a & b) => 2 
 (a | బి) => 3
 అసైన్మెంట్ ఆపరేటర్లు 
 ఆపరేటర్లు 
 వివరణ 
 సాధారణ అసైన్‌మెంట్ (=) 
కుడి వైపు ఒపెరాండ్ నుండి ఎడమ వైపు ఒపెరాండ్ వరకు విలువలను కేటాయిస్తుంది
 జోడించి, కేటాయించండి (+ =) 
ఇది ఎడమ ఒపెరాండ్‌కు కుడి ఒపెరాండ్‌ను జోడిస్తుంది మరియు ఫలితాన్ని ఎడమ ఒపెరాండ్‌కు కేటాయిస్తుంది.
 తీసివేసి, అప్పగించడం (- =) 
ఇది ఎడమ ఒపెరాండ్ నుండి కుడి ఒపెరాండ్‌ను తీసివేస్తుంది మరియు ఫలితాన్ని ఎడమ ఒపెరాండ్‌కు కేటాయిస్తుంది.
 గుణించాలి మరియు అప్పగించండి (* =) 
ఇది కుడి ఒపెరాండ్‌ను ఎడమ ఒపెరాండ్‌తో గుణిస్తుంది మరియు ఫలితాన్ని ఎడమ ఒపెరాండ్‌కు కేటాయిస్తుంది.
 విభజించి అప్పగించడం (/ =) 
ఇది ఎడమ ఒపెరాండ్‌ను కుడి ఒపెరాండ్‌తో విభజిస్తుంది మరియు ఫలితాన్ని ఎడమ ఒపెరాండ్‌కు కేటాయిస్తుంది.
 ఉదాహరణ: 
var a: number = 12 var b: number = 10 a = b console.log ('a = b:' + a) a + = b console.log ('a + = b:' + a) a - = b console .log ('a- = b:' + a)
 అవుట్పుట్: 
a = బి: 10 
 a + = బి: 20 
 a - = b: 10
ఇవి వేర్వేరు ఆపరేటర్లు. ఇప్పుడు మన టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌తో ముందుకు సాగి లూప్‌ల గురించి తెలుసుకుందాం.
 ఉచ్చులు 
కోడ్ యొక్క బ్లాక్‌ను అనేకసార్లు అమలు చేయాల్సిన పరిస్థితులు ఉండవచ్చు. జ లూప్ స్టేట్మెంట్ ఒక స్టేట్మెంట్ లేదా స్టేట్మెంట్ సమూహాన్ని చాలాసార్లు అమలు చేయడానికి అనుమతిస్తుంది.
టైప్‌స్క్రిప్ట్ లూప్‌లను ఇలా వర్గీకరించవచ్చు:
 లూప్ కోసం 
ది లూప్ కోసం ఖచ్చితమైన లూప్ యొక్క అమలు.
 సింటాక్స్: 
(మొదటి వ్యక్తీకరణ రెండవ వ్యక్తీకరణ మూడవ వ్యక్తీకరణ) {// ప్రకటనలు పదేపదే అమలు చేయబడతాయి}
ఇక్కడ, లూప్ ప్రారంభమయ్యే ముందు మొదటి వ్యక్తీకరణ అమలు అవుతుంది. రెండవ వ్యక్తీకరణ లూప్ అమలు చేయవలసిన పరిస్థితి. మరియు ప్రతి కోడ్ బ్లాక్ అమలు చేసిన తర్వాత మూడవ వ్యక్తీకరణ అమలు అవుతుంది.
 ఉదాహరణ: 
కోసం (i = 0 i లెట్<2 i++) { console.log ('Execute block statement' + i) }
 అవుట్పుట్: 
బ్లాక్ స్టేట్మెంట్ 0 ను అమలు చేయండి 
బ్లాక్ స్టేట్మెంట్ 1 ను అమలు చేయండి
 లూప్ అయితే 
పేర్కొన్న లూప్ ప్రతిసారీ పేర్కొన్నప్పుడు ఒప్పును అంచనా వేస్తుంది.
 సింటాక్స్: 
(షరతు వ్యక్తీకరణ) {// కోడ్ బ్లాక్ అమలు చేయబడాలి}
 ఉదాహరణ: 
నేను: సంఖ్య = 1 అయితే (i<3) { console.log( 'Block statement execution no.' + i ) i++ }
 అవుట్పుట్: 
బ్లాక్ స్టేట్మెంట్ ఎగ్జిక్యూషన్ నెం .1 
బ్లాక్ స్టేట్మెంట్ ఎగ్జిక్యూషన్ నెం .2
 డు..వీల్ లూప్ 
డూ & హెల్పైల్ లూప్ టైమ్ లూప్ మాదిరిగానే ఉంటుంది, అయితే ఇది లూప్ అమలు చేసిన మొదటిసారి పరిస్థితిని అంచనా వేయదు.
 సింటాక్స్: 
condition // కోడ్ బ్లాక్‌ను అమలు చేయాలంటే} (షరతు వ్యక్తీకరణ)
 ఉదాహరణ: 
  
i: number = 1 do {console.log ('బ్లాక్ స్టేట్మెంట్ ఎగ్జిక్యూషన్ నం.' + I) i ++} అయితే (i<3)
 అవుట్పుట్: 
బ్లాక్ స్టేట్మెంట్ ఎగ్జిక్యూషన్ నెం .1 
బ్లాక్ స్టేట్మెంట్ ఎగ్జిక్యూషన్ నెం .2
ఇవి కాకుండా, టైప్‌స్క్రిప్ట్‌లో బ్రేక్ అండ్ కంటిన్యూ స్టేట్‌మెంట్‌లు లూప్‌లో ఉపయోగించబడతాయి.
 బ్రేక్ స్టేట్మెంట్ 
నిర్మాణం నుండి నియంత్రణ తీసుకోవడానికి బ్రేక్ స్టేట్మెంట్ ఉపయోగించబడుతుంది. లూప్‌లో బ్రేక్ స్టేట్‌మెంట్‌ను ఉపయోగించడం ప్రోగ్రామ్‌ను లూప్ నుండి నిష్క్రమించడానికి సహాయపడుతుంది.
 ఉదాహరణ: 
var i: సంఖ్య = 1 అయితే (i<=10) { if (i % 5 == 0) { console.log ('The first multiple of 5 between 1 and 10 is : '+i) break //exit the loop if the first multiple is found } i++ } //outputs 5 and exits the loop
 అవుట్పుట్: 
1 మరియు 10 మధ్య 5 యొక్క మొదటి గుణకం: 5
 ప్రకటన కొనసాగించండి 
నిరంతర ప్రకటన ప్రస్తుత పునరావృతంలో తదుపరి స్టేట్‌మెంట్‌లను దాటవేస్తుంది మరియు నియంత్రణను లూప్ ప్రారంభానికి తీసుకువెళుతుంది.
 ఉదాహరణ: 
var num: number = 0 var count: number = 0 for (num = 0num<=10num++) { if (num % 2==0) { continue } count++ } console.log (' The count of odd values between 0 and 10 is: '+count)
 అవుట్పుట్: 
0 మరియు 10 మధ్య బేసి విలువల సంఖ్య: 5
టైప్‌స్క్రిప్ట్‌లోని విభిన్న ఉచ్చులు ఇవి. ఇప్పుడు, మన టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌తో ముందుకు సాగి ఫంక్షన్లను అర్థం చేసుకుందాం.
 విధులు 
జావాస్క్రిప్ట్‌లో, విధులు ఇది ఫంక్షనల్ ప్రోగ్రామింగ్ భాష కాబట్టి చాలా ముఖ్యమైన భాగం. ఫంక్షన్ నిర్వహించదగినది మరియు పునర్వినియోగపరచదగినది మరియు చదవగలిగే బ్లాక్‌లుగా నిర్వహించబడుతుందని విధులు నిర్ధారిస్తాయి. టైప్‌స్క్రిప్ట్ తరగతులు మరియు మాడ్యూళ్ల భావనను అందిస్తున్నప్పటికీ, విధులు ఇప్పటికీ భాషలో అంతర్భాగం.
 విధులు అని పేరు పెట్టారు 
ఇచ్చిన ఫంక్షన్ ద్వారా ఫంక్షన్‌ను ప్రకటించడానికి మరియు కాల్ చేయడానికి పేరు పెట్టబడిన ఫంక్షన్ ఉపయోగించబడుతుంది.
 ఉదాహరణ: 
ఫంక్షన్ ప్రదర్శన () {console.log ('టైప్‌స్క్రిప్ట్ ఫంక్షన్')} ప్రదర్శన ()
 అవుట్పుట్: 
టైప్‌స్క్రిప్ట్ ఫంక్షన్
 అనామక ఫంక్షన్ 
అనామక ఫంక్షన్ వ్యక్తీకరణగా నిర్వచించబడినది. ఈ వ్యక్తీకరణ వేరియబుల్‌లో నిల్వ చేయబడుతుంది. ఫంక్షన్ నిల్వ చేయబడిన వేరియబుల్ పేరును ఉపయోగించి ఈ ఫంక్షన్లు ప్రారంభించబడతాయి.
 ఉదాహరణ: 
గ్రీటింగ్ = ఫంక్షన్ () let console.log ('టైప్‌స్క్రిప్ట్ ఫంక్షన్')} గ్రీటింగ్ ()
 అవుట్పుట్: 
టైప్‌స్క్రిప్ట్ ఫంక్షన్
 బాణం ఫంక్షన్ 
కొవ్వు బాణం సంకేతాలు అనామక ఫంక్షన్ల కోసం ఉపయోగించబడతాయి, అనగా ఫంక్షన్ వ్యక్తీకరణల కోసం. వాటిని ఇతర భాషలలో లాంబ్డా ఫంక్షన్లు అని కూడా పిలుస్తారు.
 సింటాక్స్: 
(param1, param2, ..., paramN) => వ్యక్తీకరణ
కొవ్వు బాణం (=>) ను ఉపయోగించడం వల్ల ‘ఫంక్షన్’ కీవర్డ్‌ని ఉపయోగించాల్సిన అవసరం తగ్గుతుంది. పారామితులు కోణీయ బ్రాకెట్లలో పంపబడతాయి మరియు ఫంక్షన్ వ్యక్తీకరణ వంకర బ్రాకెట్లలోనే ఉంటుంది}}.
 ఉదాహరణ: 
sum = (x: number, y: number): number => {return x + y} sum (10, 30) // return 40
 ఫంక్షన్ ఓవర్లోడింగ్ 
టైప్‌స్క్రిప్ట్ ఫంక్షన్ ఓవర్‌లోడింగ్ భావనను అందిస్తుంది. అందువల్ల, మీరు ఒకే పేరుతో బహుళ ఫంక్షన్లను కలిగి ఉండవచ్చు కాని విభిన్న పారామితి రకాలు మరియు రిటర్న్ రకం.
 ఉదాహరణ: 
ఫంక్షన్ యాడ్ (ఎ: స్ట్రింగ్, బి: స్ట్రింగ్): స్ట్రింగ్ ఫంక్షన్ యాడ్ (ఎ: నంబర్, బి: నంబర్): సంఖ్య రిటర్న్ ఎ + బి} యాడ్ ('హలో', 'ఎడురేకా') // రిటర్న్స్ 'హలో ఎడురేకా' యాడ్ ( 10, 10) // రిటర్న్స్ 20
పై ఉదాహరణలో, మనకు రెండు ఫంక్షన్ డిక్లరేషన్లు మరియు ఒక ఫంక్షన్ అమలుతో ఒకే ఫంక్షన్ యాడ్ () ఉంది. మొదటి సంతకం టైప్ స్ట్రింగ్ యొక్క రెండు పారామితులను కలిగి ఉంది, రెండవ సంతకం రకం సంఖ్య యొక్క రెండు పారామితులను కలిగి ఉంది.
ఇవి వివిధ రకాలైన విధులు. ఇప్పుడు, మన టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌తో ముందుకు సాగండి మరియు టైప్‌స్క్రిప్ట్‌లోని తీగలను అర్థం చేసుకుందాం.
 టైప్‌స్క్రిప్ట్ ట్యుటోరియల్: స్ట్రింగ్స్ 
ది  టెక్స్ట్ డేటాను నిల్వ చేయడానికి ఉపయోగించే మరొక ఆదిమ డేటా రకం. స్ట్రింగ్ విలువలు ఒకే కొటేషన్ మార్కులు లేదా డబుల్ కొటేషన్ మార్కులతో ఉంటాయి.
 సింటాక్స్: 
var var_name = క్రొత్త స్ట్రింగ్ (స్ట్రింగ్)
స్ట్రింగ్ ఆబ్జెక్ట్‌లో అందుబాటులో ఉన్న పద్ధతుల యొక్క విభిన్న లక్షణాలు ఉన్నాయి:
 బిల్డర్ - ఇది వస్తువును సృష్టించిన స్ట్రింగ్ ఫంక్షన్‌కు సూచనను అందిస్తుంది
 పొడవు - ఇది స్ట్రింగ్ యొక్క పొడవును అందిస్తుంది
 నమూనా - ఈ ఆస్తి ఒక వస్తువుకు లక్షణాలు మరియు పద్ధతులను జోడించడానికి మిమ్మల్ని అనుమతిస్తుంది
 ఉదాహరణ: 
పేరు = క్రొత్త స్ట్రింగ్ ('ఎడురేకాకు స్వాగతం!') console.log ('సందేశం:' + పేరు) console.log ('పొడవు:' + name.length)
 అవుట్పుట్: 
సందేశం: ఎడురేకాకు స్వాగతం! 
 పొడవు: 19
 స్ట్రింగ్ పద్ధతులు 
స్ట్రింగ్ ఆబ్జెక్ట్‌లోని పద్ధతుల జాబితా:
 విధానం 
 వివరణ 
 చార్అట్ () 
ఇది పేర్కొన్న సూచిక వద్ద అక్షరాన్ని తిరిగి ఇస్తుంది
 charCodeAt () 
ఇది ఇచ్చిన సూచిక వద్ద అక్షరం యొక్క యూనికోడ్ విలువను సూచించే సంఖ్యను అందిస్తుంది
 concat () 
రెండు తీగల యొక్క వచనాన్ని మిళితం చేసి కొత్త స్ట్రింగ్‌ను అందిస్తుంది
 indexOf () 
పేర్కొన్న విలువ యొక్క మొదటి సంఘటన యొక్క కాలింగ్ స్ట్రింగ్ ఆబ్జెక్ట్‌లోని సూచికను అందిస్తుంది
 lastIndexOf () 
ఇది పేర్కొన్న విలువ యొక్క చివరి సంఘటన యొక్క కాలింగ్ స్ట్రింగ్ ఆబ్జెక్ట్‌లోని సూచికను తిరిగి ఇస్తుంది
 మ్యాచ్ () 
స్ట్రింగ్‌కు వ్యతిరేకంగా సాధారణ వ్యక్తీకరణతో సరిపోలడానికి ఉపయోగిస్తారు
 లొకేల్ కంపేర్ () 
రిఫరెన్స్ స్ట్రింగ్ ముందు లేదా తరువాత వస్తుందా లేదా క్రమబద్ధీకరణ క్రమంలో ఇచ్చిన స్ట్రింగ్‌కు సమానమా అని సూచించే సంఖ్యను అందిస్తుంది
 వెతకండి() 
ఇది సాధారణ వ్యక్తీకరణ మరియు పేర్కొన్న స్ట్రింగ్ మధ్య మ్యాచ్ కోసం శోధనను అమలు చేస్తుంది
 భర్తీ () 
సాధారణ వ్యక్తీకరణ మరియు స్ట్రింగ్ మధ్య సరిపోలికను కనుగొనడానికి మరియు సరిపోలిన సబ్‌స్ట్రింగ్‌ను కొత్త సబ్‌స్ట్రింగ్‌తో భర్తీ చేయడానికి ఉపయోగిస్తారు
 ముక్క () 
ఇది స్ట్రింగ్ యొక్క ఒక విభాగాన్ని సంగ్రహిస్తుంది మరియు క్రొత్త స్ట్రింగ్‌ను అందిస్తుంది
 స్ప్లిట్ () 
స్ట్రింగ్‌ను సబ్‌స్ట్రింగ్‌లుగా విభజించడం ద్వారా స్ట్రింగ్ ఆబ్జెక్ట్‌ను తీగల శ్రేణిలోకి విభజిస్తుంది
 substr () 
పేర్కొన్న సంఖ్యలో అక్షరాల ద్వారా పేర్కొన్న ప్రదేశంలో ప్రారంభమయ్యే స్ట్రింగ్‌లోని అక్షరాలను అందిస్తుంది
 substring () 
ఇది రెండు సూచికల మధ్య స్ట్రింగ్‌లోని అక్షరాలను స్ట్రింగ్‌లోకి అందిస్తుంది
 toLocaleLowerCase () 
ప్రస్తుత లొకేల్‌ను గౌరవిస్తూ స్ట్రింగ్‌లోని అక్షరాలు చిన్న కేసుగా మార్చబడతాయి
 toLocaleUpperCase () 
ప్రస్తుత లొకేల్‌ను గౌరవిస్తూ స్ట్రింగ్‌లోని అక్షరాలు ఎగువ కేసుగా మార్చబడతాయి
 toLowerCase () 
ఇది లోయర్ కేస్‌గా మార్చబడిన కాలింగ్ స్ట్రింగ్ విలువను తిరిగి ఇస్తుంది
 toUpperCase () 
ఇది పెద్ద అక్షరానికి మార్చబడిన కాలింగ్ స్ట్రింగ్ విలువను తిరిగి ఇస్తుంది
 toString () 
పేర్కొన్న వస్తువును సూచించే స్ట్రింగ్‌ను అందిస్తుంది
 యొక్క విలువ() 
పేర్కొన్న వస్తువు యొక్క ఆదిమ విలువను చూపుతుంది
 ఉదాహరణ: 
str: string = 'Edureka కు స్వాగతం' str.charAt (0) // రిటర్న్స్ 'w' str.charAt (2) // రిటర్న్స్ 'l' 'ఎదురేకాకు స్వాగతం' .చార్అట్ (2) రిటర్న్స్ 'l' str1 లెట్ . ') // రిటర్న్స్' స్వాగతం '
ఇప్పుడు మీకు తీగల గురించి తెలుసు, ఈ టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌తో ముందుకు సాగండి మరియు శ్రేణులను అర్థం చేసుకుందాం.
 టైప్‌స్క్రిప్ట్‌లో శ్రేణులు 
ఒక అమరిక ఒక ప్రత్యేక రకం డేటా రకం, ఇది వివిధ సింటాక్స్ ఉపయోగించి వరుసగా వివిధ డేటా రకాల బహుళ విలువలను నిల్వ చేస్తుంది. అర్రే ఎలిమెంట్స్ మూలకం యొక్క సబ్స్క్రిప్ట్ లేదా ఇండెక్స్ అని పిలువబడే ప్రత్యేకమైన పూర్ణాంకం ద్వారా గుర్తించబడతాయి.
నైరూప్య తరగతి మరియు ఇంటర్ఫేస్ వ్యత్యాసం
 సింటాక్స్: 
var array_name [: datatype] // డిక్లరేషన్ శ్రేణి_పేరు = [val1, val2, valn ..] // ప్రారంభించడం
 ఉదాహరణ: 
పేర్లను అనుమతించండి: అర్రే పేర్లు = ['జాన్', 'డైసీ', 'రాచెల్'] లెట్ ఐడిలు: అర్రే ఐడిలు = [101, 700, 321]
 శ్రేణి పద్ధతులు 
వేర్వేరు ప్రయోజనాల కోసం ఉపయోగించగల విభిన్న శ్రేణి పద్ధతుల జాబితా ఇక్కడ ఉంది:
 విధానం 
 వివరణ 
 ఫిల్టర్ () 
ఈ శ్రేణి యొక్క అన్ని అంశాలతో క్రొత్త శ్రేణిని సృష్టిస్తుంది, దీని కోసం అందించిన వడపోత ఫంక్షన్ నిజమైనది
 ప్రతి () 
ఈ శ్రేణిలోని ప్రతి మూలకం అందించిన పరీక్ష ఫంక్షన్‌ను సంతృప్తిపరిస్తే నిజం అవుతుంది
 concat () 
ఇతర శ్రేణులతో కలిసిన ఈ శ్రేణితో కూడిన క్రొత్త శ్రేణిని అందిస్తుంది
 indexOf () 
పేర్కొన్న విలువకు సమానమైన శ్రేణిలోని మూలకం యొక్క మొదటి లేదా తక్కువ సూచికను అందిస్తుంది
 ప్రతి() 
శ్రేణిలోని ప్రతి మూలకం కోసం ఒక ఫంక్షన్‌ను పిలుస్తుంది
 చేరండి () 
శ్రేణి యొక్క అన్ని అంశాలను స్ట్రింగ్‌లో కలుస్తుంది
 lastIndexOf () 
పేర్కొన్న విలువకు సమానమైన శ్రేణిలోని మూలకం యొక్క చివరి లేదా గొప్ప సూచికను అందిస్తుంది
 మ్యాప్ () 
ఈ శ్రేణిలోని ప్రతి మూలకంపై అందించిన ఫంక్షన్‌ను పిలిచే ఫలితాలతో క్రొత్త శ్రేణిని సృష్టిస్తుంది
 పుష్ () 
శ్రేణి చివరికి ఒకటి లేదా అంతకంటే ఎక్కువ అంశాలను జోడిస్తుంది మరియు శ్రేణి యొక్క క్రొత్త పొడవును అందిస్తుంది
 పాప్ () 
శ్రేణి నుండి చివరి మూలకాన్ని తీసివేసి, ఆ మూలకాన్ని తిరిగి ఇస్తుంది
 తగ్గించండి () 
శ్రేణి యొక్క రెండు విలువలకు వ్యతిరేకంగా ఒకేసారి ఒక ఫంక్షన్‌ను ఎడమ నుండి కుడికి ఒకే విలువకు తగ్గించండి
 తగ్గించు రైట్ () 
శ్రేణి యొక్క రెండు విలువలకు వ్యతిరేకంగా ఒకేసారి ఒక ఫంక్షన్‌ను కుడి నుండి ఎడమకు ఒకే విలువకు తగ్గించండి
 రివర్స్ () 
శ్రేణి యొక్క మూలకాల క్రమాన్ని తిరగరాస్తుంది
 మార్పు() 
శ్రేణి నుండి మొదటి మూలకాన్ని తీసివేసి, ఆ మూలకాన్ని తిరిగి ఇస్తుంది
 ముక్క () 
శ్రేణి యొక్క ఒక విభాగాన్ని సంగ్రహిస్తుంది మరియు క్రొత్త శ్రేణిని అందిస్తుంది
 కొన్ని () 
ఈ శ్రేణిలోని కనీసం ఒక మూలకం అందించిన పరీక్ష ఫంక్షన్‌ను సంతృప్తిపరిస్తే అది నిజం అవుతుంది
 క్రమబద్ధీకరించు () 
ఇది శ్రేణి యొక్క అంశాలను క్రమబద్ధీకరిస్తుంది
 toString () 
శ్రేణి మరియు దాని అంశాలను సూచించే స్ట్రింగ్‌ను అందిస్తుంది
 స్ప్లైస్ () 
ఇది శ్రేణి నుండి మూలకాలను జోడిస్తుంది మరియు / లేదా తొలగిస్తుంది
 అన్షిఫ్ట్ () 
శ్రేణి ముందు ఒకటి లేదా అంతకంటే ఎక్కువ అంశాలను జోడిస్తుంది మరియు శ్రేణి యొక్క క్రొత్త పొడవును అందిస్తుంది
 ఉదాహరణ: 
var పేరు: అర్రే = ['జాన్', 'డైసీ', 'తారా'] name.sort () console.log (పేరు) // అవుట్పుట్: ['డైసీ', 'జాన్', 'తారా'] console.log ( name.pop ()) // అవుట్పుట్: తారా name.push ('రాచెల్') console.log (పేరు) // అవుట్పుట్: ['జాన్', 'డైసీ', 'రాచెల్']
ఇప్పుడు ఈ టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌తో ముందుకు సాగి ఇంటర్‌ఫేస్‌ల గురించి తెలుసుకుందాం.
 టైప్‌స్క్రిప్ట్ ఇంటర్‌ఫేస్‌లు 
ఇంటర్ఫేస్ అనేది మీ అప్లికేషన్‌లోని ఒప్పందాన్ని నిర్వచించే ఒక నిర్మాణం. తరగతులు అనుసరించాల్సిన వాక్యనిర్మాణాన్ని ఇది నిర్వచిస్తుంది. ఇది సభ్యుల ప్రకటనను మాత్రమే కలిగి ఉంటుంది మరియు సభ్యులను నిర్వచించడం ఉత్పన్న తరగతి యొక్క బాధ్యత.
 ఉదాహరణ: 
ఇంటర్ఫేస్ ఉద్యోగి {empID: సంఖ్య empName: స్ట్రింగ్ getSalary: (సంఖ్య) => సంఖ్య // బాణం ఫంక్షన్ getManagerName (సంఖ్య): స్ట్రింగ్}
పై ఉదాహరణలో, ది ఉద్యోగి ఇంటర్ఫేస్ రెండు లక్షణాలను కలిగి ఉంది empID మరియు empName . ఇది ఒక పద్ధతి ప్రకటనను కూడా కలిగి ఉంటుంది getSalaray ఉపయోగించి బాణం ఫంక్షన్ దీనిలో ఒక సంఖ్య పరామితి మరియు సంఖ్య తిరిగి వచ్చే రకం ఉన్నాయి. ది getManagerName పద్ధతి సాధారణ ఫంక్షన్‌ను ఉపయోగించి ప్రకటించబడుతుంది.
 టైప్‌స్క్రిప్ట్  తరగతులు 
టైప్‌స్క్రిప్ట్ తరగతులను ప్రవేశపెట్టింది, తద్వారా వారు ఎన్‌క్యాప్సులేషన్ మరియు నైరూప్యత వంటి ఆబ్జెక్ట్-ఓరియెంటెడ్ టెక్నిక్‌ల యొక్క ప్రయోజనాలను పొందవచ్చు. టైప్‌స్క్రిప్ట్‌లోని తరగతి ప్లాట్‌ఫారమ్‌లు మరియు బ్రౌజర్‌లలో పనిచేయడానికి టైప్‌స్క్రిప్ట్ కంపైలర్ చేత సాదా జావాస్క్రిప్ట్ ఫంక్షన్లకు కంపైల్ చేయబడింది.
ఒక తరగతి కింది వాటిని కలిగి ఉంటుంది:
 బిల్డర్ 
 లక్షణాలు 
 పద్ధతులు 
 ఉదాహరణ: 
తరగతి ఉద్యోగి {empID: number empName: స్ట్రింగ్ కన్స్ట్రక్టర్ (ID: number, name: string) {this.empName = name this.empID = ID} getSalary (): సంఖ్య {తిరిగి 40000}}
 వారసత్వం 
టైప్‌స్క్రిప్ట్ మద్దతు ఇస్తుంది వారసత్వం ఇప్పటికే ఉన్న తరగతి నుండి క్రొత్త తరగతులను సృష్టించే ప్రోగ్రామ్ యొక్క సామర్థ్యం ఇది. క్రొత్త తరగతులను సృష్టించడానికి విస్తరించిన తరగతిని పేరెంట్ క్లాస్ లేదా సూపర్ క్లాస్ అంటారు. కొత్తగా సృష్టించిన తరగతులను చైల్డ్ లేదా సబ్ క్లాసులు అంటారు.
ఒక తరగతి ‘విస్తరిస్తుంది’ కీవర్డ్‌ని ఉపయోగించి మరొక తరగతి నుండి వారసత్వంగా వస్తుంది. పిల్లల తరగతులు మాతృ తరగతి నుండి ప్రైవేట్ సభ్యులు మరియు కన్స్ట్రక్టర్లు మినహా అన్ని ఆస్తులు మరియు పద్ధతులను వారసత్వంగా పొందుతాయి. కానీ, టైప్‌స్క్రిప్ట్ బహుళ వారసత్వానికి మద్దతు ఇవ్వదు.
 సింటాక్స్: 
తరగతి పిల్లల_క్లాస్_పేరు పేరెంట్_క్లాస్_పేరును విస్తరిస్తుంది
 ఉదాహరణ: 
తరగతి వ్యక్తి {పేరు: స్ట్రింగ్ కన్స్ట్రక్టర్ (పేరు: స్ట్రింగ్) {this.name = name}} తరగతి ఉద్యోగి వ్యక్తిని విస్తరిస్తాడు {empID: సంఖ్య కన్స్ట్రక్టర్ (empID: number, name: string) {super (name) this.empID = empid} displayName (): void {console.log ('Name =' + this.name + ', ఎంప్లాయీ ID =' + this.empID)}} emp = కొత్త ఉద్యోగి (701, 'జాసన్') emp.displayName () // పేరు = జాసన్, ఉద్యోగి ID = 701
ఇప్పుడు మీకు తరగతుల గురించి తెలుసు, ఈ టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌తో ముందుకు సాగి, వస్తువుల గురించి తెలుసుకుందాం.
 టైప్‌స్క్రిప్ట్‌లోని వస్తువులు 
ఆబ్జెక్ట్ అనేది వేరే కీ-విలువ జతలను కలిగి ఉన్న ఒక ఉదాహరణ. విలువలు స్కేలార్ విలువలు లేదా విధులు లేదా ఇతర వస్తువుల శ్రేణి కావచ్చు.
 సింటాక్స్: 
var object_name = {key1: “value1”, // స్కేలార్ విలువ key2: “value”, key3: function () {// functions}, key4: [“content1”, “content2”]
ఒక వస్తువు స్కేలార్ విలువలు, విధులు మరియు శ్రేణులు మరియు టుపుల్స్ వంటి నిర్మాణాలను కలిగి ఉంటుంది.
 ఉదాహరణ: 
var వ్యక్తి = {మొదటి పేరు: 'డానీ', చివరి పేరు: 'గ్రీన్'} // ఆబ్జెక్ట్ విలువలను యాక్సెస్ చేయండి console.log (person.firstname) console.log (person.lastname)
కంపైల్ చేసినప్పుడు, ఇది జావాస్క్రిప్ట్‌లో అదే కోడ్‌ను ఉత్పత్తి చేస్తుంది.
 అవుట్పుట్: 
డానీ 
 ఆకుపచ్చ
ఇవి టైప్‌స్క్రిప్ట్ యొక్క విభిన్న ముఖ్యమైన అంశాలు. ఇప్పుడు, ఈ టైప్‌స్క్రిప్ట్ ట్యుటోరియల్‌తో ముందుకు సాగండి మరియు వినియోగ కేసును అర్థం చేసుకోవడానికి ఒక ఉదాహరణను చూద్దాం.
 టైప్‌స్క్రిప్ట్ ట్యుటోరియల్: కేస్ ఉపయోగించండి 
ఇక్కడ, ఉన్నదాన్ని ఎలా మార్చాలో నేర్చుకుంటాము  టైప్‌స్క్రిప్ట్‌కు.
మేము టైప్‌స్క్రిప్ట్ ఫైల్‌ను కంపైల్ చేసినప్పుడు, అది అదే పేరుతో సంబంధిత జావాస్క్రిప్ట్ ఫైల్‌ను ఉత్పత్తి చేస్తుంది. ఇక్కడ, ఇన్పుట్ వలె పనిచేసే మా అసలు జావాస్క్రిప్ట్ ఫైల్ ఒకే డైరెక్టరీలో ఉండదని మేము నిర్ధారించుకోవాలి, తద్వారా టైప్ స్క్రిప్ట్ వాటిని భర్తీ చేయదు.
జావాస్క్రిప్ట్ నుండి టైప్‌స్క్రిప్ట్‌కు వలస వెళ్ళే ప్రక్రియ క్రింది దశలను కలిగి ఉంటుంది:
 1. ప్రాజెక్ట్కు tsconfig.json ఫైల్‌ను జోడించండి 
మీరు ప్రాజెక్ట్‌కు tsconfig.json ఫైల్‌ను జోడించాలి. ప్రాజెక్ట్ యొక్క సంకలన ఎంపికలను నిర్వహించడానికి టైప్‌స్క్రిప్ట్ tsconfig.json ఫైల్‌ను ఉపయోగిస్తుంది, మీరు ఏ ఫైళ్ళను చేర్చాలనుకుంటున్నారు మరియు మినహాయించాలనుకుంటున్నారు.
comp 'కంపైలర్ ఆప్షన్స్': {'అవుట్‌డిర్': './బిల్ట్', 'allowJs': true, 'target': 'es5'}, 'include': ['./src/**/*']}
 2. బిల్డ్ సాధనంతో ఇంటిగ్రేట్ చేయండి 
చాలా జావాస్క్రిప్ట్ ప్రాజెక్టులు గల్ప్ లేదా వెబ్‌ప్యాక్ వంటి ఇంటిగ్రేటెడ్ బిల్డ్ సాధనాన్ని కలిగి ఉంటాయి. మీరు ఈ క్రింది మార్గాల్లో వెబ్‌ప్యాక్‌తో ప్రాజెక్ట్‌లను అనుసంధానించవచ్చు:
కింది ఆదేశాన్ని టెర్మినల్‌లో అమలు చేయండి:
pm npm అద్భుతం-టైప్‌స్క్రిప్ట్-లోడర్ సోర్స్-మ్యాప్-లోడర్‌ను ఇన్‌స్టాల్ చేయండి
వెబ్‌ప్యాక్ ఇంటిగ్రేషన్‌లో, సోర్స్ కోడ్‌ను సులభంగా డీబగ్గింగ్ చేయడానికి మీరు సోర్స్-మ్యాప్-లోడర్‌తో కలిపి అద్భుతమైన-టైప్‌స్క్రిప్ట్-లోడర్‌ను ఉపయోగిస్తారు.
రెండవది, లోడర్‌లను చేర్చడానికి మా వెబ్‌ప్యాక్.కాన్ఫిగ్.జెస్ ఫైల్‌లో మాడ్యూల్ కాన్ఫిగర్ ప్రాపర్టీని విలీనం చేయండి.
 3. అన్ని .js ఫైళ్ళను .ts ఫైళ్ళకు తరలించండి 
ఈ దశలో, మీరు .js ఫైల్‌ను .ts ఫైల్‌కు పేరు మార్చాలి. అదేవిధంగా, ఫైల్ JSX ను ఉపయోగిస్తే, మీరు దానిని .tsx గా పేరు మార్చాలి. ఇప్పుడు, టైప్‌స్క్రిప్ట్‌కు మద్దతిచ్చే ఎడిటర్‌లో మేము ఆ ఫైల్‌ను తెరిస్తే, కొన్ని సంకేతాలు సంకలన లోపాలను ఇవ్వడం ప్రారంభించవచ్చు. కాబట్టి, ఫైళ్ళను ఒక్కొక్కటిగా మార్చడం సంకలన లోపాలను మరింత తేలికగా నిర్వహించడానికి అనుమతిస్తుంది. మార్పిడి సమయంలో టైప్‌స్క్రిప్ట్ ఏదైనా సంకలన లోపాలను కనుగొంటే, అది ఇప్పటికీ కోడ్‌ను అనువదించగలదు.
 4. లోపాల కోసం తనిఖీ చేయండి 
Js ఫైల్‌ను ts ఫైల్‌కు తరలించిన తర్వాత, వెంటనే, టైప్‌స్క్రిప్ట్ మా కోడ్ యొక్క టైప్ చెకింగ్‌ను ప్రారంభిస్తుంది. కాబట్టి, మీరు జావాస్క్రిప్ట్ కోడ్‌లో విశ్లేషణ లోపాలను పొందవచ్చు.
 5. మూడవ పార్టీ జావాస్క్రిప్ట్ లైబ్రరీలను ఉపయోగించండి 
జావాస్క్రిప్ట్ ప్రాజెక్టులు వంటి మూడవ పార్టీ లైబ్రరీలను ఉపయోగిస్తాయి  లేదా లోడాష్. ఫైళ్ళను కంపైల్ చేయడానికి, టైప్‌స్క్రిప్ట్ ఈ లైబ్రరీలలోని అన్ని వస్తువుల రకాలను తెలుసుకోవాలి. జావాస్క్రిప్ట్ లైబ్రరీల కోసం టైప్‌స్క్రిప్ట్ టైప్ డెఫినిషన్ ఫైల్స్ ఇప్పటికే ఖచ్చితంగా టైప్‌లో అందుబాటులో ఉన్నాయి. కాబట్టి, ఈ రకాన్ని బాహ్యంగా ఇన్‌స్టాల్ చేయవలసిన అవసరం లేదు. మీరు మా ప్రాజెక్ట్‌లో ఉపయోగించిన రకాలను మాత్రమే ఇన్‌స్టాల్ చేయాలి.
J క్వెరీ కోసం, మీరు నిర్వచనాన్ని ఇన్‌స్టాల్ చేయవచ్చు:
pm npm ఇన్‌స్టాల్ @ రకాలు / j క్వెరీ
దీని తరువాత, జావాస్క్రిప్ట్ ప్రాజెక్ట్‌లో మార్పులు చేయండి, బిల్డ్ సాధనాన్ని అమలు చేయండి. ఇప్పుడు, మీరు టైప్ స్క్రిప్ట్ ప్రాజెక్ట్ను సాదా జావాస్క్రిప్ట్లో కంపైల్ చేయాలి, అది బ్రౌజర్లో అమలు చేయగలదు.
దీనితో, మేము ఈ టైప్‌స్క్రిప్ట్ ట్యుటోరియల్ చివరికి వచ్చాము. టైప్‌స్క్రిప్ట్ యొక్క అన్ని ముఖ్యమైన అంశాలను మీరు అర్థం చేసుకున్నారని నేను ఆశిస్తున్నాను.
 చూడండి     ఎడురేకా చేత.  వెబ్ డెవలప్‌మెంట్ సర్టిఫికేషన్ శిక్షణ HTML5, CSS3, ట్విట్టర్ బూట్‌స్ట్రాప్ 3, j క్వెరీ మరియు గూగుల్ API లను ఉపయోగించి ఆకట్టుకునే వెబ్‌సైట్‌లను ఎలా సృష్టించాలో తెలుసుకోవడానికి మరియు అమెజాన్ సింపుల్ స్టోరేజ్ సర్వీస్ (S3) కు ఎలా అమలు చేయాలో తెలుసుకోవడానికి మీకు సహాయం చేస్తుంది. 
 మాకు ప్రశ్న ఉందా? దయచేసి దీనిని “టైప్‌స్క్రిప్ట్ ట్యుటోరియల్” యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము మిమ్మల్ని సంప్రదిస్తాము.