TypeScript apmācība: uzziniet par TypeScript pamatiem

TypeScript ir stingri ievadīts kas apkopo vienkāršā JavaScript. Šo valodu varat izmantot lietojumprogrammas mēroga JavaScript izstrādei. To var izpildīt arī jebkurā pārlūkprogrammā, jebkurā resursdatorā un jebkurā operētājsistēmā. Šajā TypeScript apmācībā mēs iekļūsim TypeScript dziļumā un izpratīsim pamatus šādā secībā:

• Ievads TypeScript
• TypeScript tipi
• Mainīgie
• Operatori
• Cilpas
• Funkcijas
• Stīgas
• Masīvi
• Saskarnes
• Klases
• Objekti
• TypeScript lietošanas gadījums

Ievads TypeScript

TypeScript ir tipizēts JavaScript superset, kas apkopo vienkāršā JavaScript. TypeScript ir tīrs objektorientēts ar klasēm, saskarnēm un statiski ierakstītām programmēšanas valodām, piemēram, C # vai . Lai kompilētu un ģenerētu JavaScript failā, ir nepieciešams kompilators. Būtībā TypeScript ir JavaScript ES6 versija ar dažām papildu funkcijām.

TypeScript kods tiek ierakstīts failā ar .ts paplašinājums un pēc tam, izmantojot kompilatoru, apkopo JavaScript. Failu var rakstīt jebkurā koda redaktorā, un kompilatoram jābūt instalētam jūsu platformā. Pēc instalēšanas komanda tsc .ts apkopo TypeScript kodu vienkāršā JavaScript failā.

Sintakse:

var message: string = 'Laipni lūdzam Edurekā!' console.log (ziņojums)

Apkopojot, tas ģenerē šādu JavaScript kodu:

// Ģenerēts pēc mašīnraksta 1.8.10 var message = 'Laipni lūdzam Edureka!' console.log (ziņojums)

TypeScript iezīmes

• Starpplatforma: TypeScript kompilatoru var instalēt jebkurā operētājsistēmā, piemēram, Windows, MacOS un Linux.

  
  
  

• Uz objektu orientēta valoda : TypeScript nodrošina tādas funkcijas kā Klases , Saskarnes un moduļi. Tādējādi tas var rakstīt objektorientētu kodu klienta puses, kā arī servera puses attīstībai.

• Statiskā tipa pārbaude : TypeScript izmanto statisko rakstīšanu un palīdz tipa pārbaudei sastādīšanas laikā. Tādējādi, rakstot kodu, palaižot skriptu, jūs varat atrast kļūdas.

• Izvēles statiskā rakstīšana : TypeScript pieļauj arī statisku rakstīšanu pēc izvēles, ja izmantojat JavaScript dinamisko rakstīšanu.

• DOM manipulācijas : Varat izmantot TypeScript, lai manipulētu ar DOM elementu pievienošanai vai noņemšanai.

• ES 6 funkcijas : TypeScript ietver lielāko daļu plānoto ECMAScript 2015 (ES 6, 7) funkciju, piemēram, klasi, saskarni, bultiņu funkcijas utt.

TypeScript izmantošanas priekšrocības

• TypeScript ir ātri, vienkārši, viegli iemācīties un darbojas ar jebkuru pārlūku vai JavaScript dzinēju.

• Tas ir līdzīgi uz JavaScript un izmanto to pašu sintaksi un semantiku.

• Tas palīdz backend izstrādātājiem rakstīt front-end kods ātrāk .

• TypeScript kodu var izsaukt no esošo JavaScript kodu . Tas darbojas arī ar esošajiem JavaScript ietvariem un bibliotēkām bez problēmām.

• Definīcijas fails ar paplašinājumu .d.ts nodrošina atbalstu esošajām JavaScript bibliotēkām, piemēram, Jquery, D3.js utt. Tātad var pievienot TypeScript kodu JavaScript bibliotēkas izmantojot tipa definīcijas, lai izmantotu tipa pārbaudes, kodu automātiskās pabeigšanas un dokumentācijas priekšrocības esošajās dinamiski ierakstītās JavaScript bibliotēkās.

• Tas ietver funkcijas no ES6 un ES7 kas var darboties ES5 līmeņa JavaScript dzinējos, piemēram, Node.js .

Tagad, kad esat sapratis, kas ir TypeScript, turpināsim šo TypeScript apmācību un apskatīsim dažādos veidus.

TypeScript tipi

Tipa sistēma attēlo dažādus valodas atbalstītos vērtību veidus. Tas pārbauda derīgums piegādāto vērtības pirms programma tos glabā vai manipulē.

To var iedalīt divos veidos, piemēram:

• Iebūvēts : Tas ietver skaitli, virkni, būla skaitli, tukšumu, nulli un nedefinētu.
• Lietotājs definēts : Tas ietver uzskaitījumus (uzskaitījumus), klases, saskarnes, masīvus un kopas.

Tagad turpināsim izmantot šo TypeScript apmācību un uzzināt vairāk par mainīgajiem.

TypeScript apmācība: mainīgie

Mainīgais ir nosaukta vieta atmiņā, ko izmanto vērtību glabāšanai.

Tipa sintakse, lai deklarētu mainīgo TypeScript, pēc mainīgā nosaukuma ietver kolu (:), kam seko tā tips. Līdzīgi kā JavaScript, mēs izmantojam var atslēgvārds deklarēt mainīgo.

Deklarējot mainīgo, ir četras iespējas:

var [identifikators]: [type-annotation] = vērtība

var [identifikators]: [tipa anotācija]

var [identifikators] = vērtība

var [identificēt]

Piemērs:

var nosaukums: string = 'margrietiņa' var empid: numurs = 1001 console.log ('vārds' + vārds) console.log ('darbinieka ID' + empid)

Apkopojot, tas ģenerēs šādu JavaScript kodu:

// ģenerēts ar mašīnrakstu 1.8.10. Var name = 'Daisy' var empid = 1001 console.log ('name' + name) console.log ('darbinieka ID:' + empid)

Izeja:

vārds: Daisy
darbinieka ID: 1001

Tagad pārejam uz nākamo mūsu TypeScript apmācības tēmu.

Operatori

Operators tiek izmantots, lai definētu funkcijas, kas tiks veiktas ar datiem. Datus, kuros darbojas operatori, sauc par operandiem. Ir dažādi veidi operatoriem TypeScript, piemēram:

• Aritmētiskie operatori
• Loģiskie operatori
• Relāciju operatori
• Operatori pa bitiem
• Uzdevumu operatori

Aritmētiskie operatori

Piemērs:

var num1: numurs = 10 var num2: skaitlis = 2 var res: skaitlis = 0 res = num1 + num2 console.log ('Summa:' + res) res = num1 - num2 console.log ('Atšķirība:' + res) res = num1 * num2 console.log ('Produkts:' + res)

Izeja:

Summa: 12
Atšķirība: 8
Produkts: 20

Loģiskie operatori

Piemērs:

var avg: skaitlis = 20 var percent: number = 90 console.log ('Vid. vērtība:' + vid. + ', procentuālā vērtība:' + proc.) var res: būla = = ((vid.> 50) && (proc.> 80. )) console.log ('(vid.> 50) && (procents> 80):', res)

Izeja:

Vidējā vērtība: 20, procentuālā vērtība: 90
(vid.> 50) && (procents> 80): nepatiesa

Relāciju operatori

Piemērs:

var num1: skaits = 10 var num2: skaitlis = 7 console.log ('num1 vērtība:' + num1) console.log ('num2 vērtība:' + num2) var res = num1> num2 console.log ('num1 lielāks par num2: '+ res) res = num1
 Izeja: 
Num1 vērtība: 10 
 Num2 vērtība: 7 
 num1 lielāks par num2: taisnība 
 num1 mazāks par num2: nepatiesa
 Operatori, kas darbojas pa bitiem 
 Operatori 
 Apraksts 
 Bitu virzienā UN (&) 
veic Būla UN operāciju katram tā veselu skaitļu argumentu bitam.
 Bitu virzienā VAI (|) 
Tas veic Būla VAI operāciju katram tā vesela skaitļa argumentu bitam.
 Bitor XOR (^) 
Tas veic Būla ekskluzīvu VAI operāciju katram tā vesela skaitļa argumentu bitam.
 Bitu virzienā NAV (~) 
Šis ir unārais operators un darbojas, apvēršot visus operanda bitus.
 Kreisā maiņa (<<) 
Tas pārvieto visus pirmā operanda bitus pa kreisi par vietu skaitu, kas norādīts otrajā operandā.
 Labā maiņa (>>) 
Kreisā operanda vērtību pārvieto pa labi ar labajā operandā norādīto bitu skaitu.
 Labā maiņa ar nulli (>>>) 
Tas ir līdzīgs operatoram >>, izņemot to, ka kreisajā pusē pārvietotie biti vienmēr ir nulle.
 Piemērs: 
var a: skaitlis = 2 // bitu prezentācija 10 var b: skaitlis = 3 // bitu noformējums 11 var rezultāts rezultāts = (a & b) console.log ('(a & b) =>', rezultāts) rezultāts = ( a | b) console.log ('(a | b) =>', rezultāts)
 Izeja: 
(a & b) => 2 
 (a | b) => 3
 Uzdevumu operatori 
 Operatori 
 Apraksts 
 Vienkāršs uzdevums (=) 
Piešķir vērtības no labās puses operanda līdz kreisās puses operandam
 Pievienošana un piešķiršana (+ =) 
Tas pievieno labo operandu kreisajam operandam un rezultātu piešķir kreisajam operandam.
 Atņemt un piešķirt (- =) 
Tas atņem labo operandu no kreisā operanda un rezultātu piešķir kreisajam operandam.
 Reizināt un piešķirt (* =) 
Tas reizina labo operandu ar kreiso operandu un rezultātu piešķir kreisajam operandam.
 Sadalīt un piešķirt (/ =) 
Tas sadala kreiso operandu ar labo operandu un rezultātu piešķir kreisajam operandam.
 Piemērs: 
var a: skaitlis = 12 var b: skaitlis = 10 a = b konsole.log ('a = b:' + a) a + = b konsole.log ('a + = b:' + a) a - = b konsole .log ('a- = b:' + a)
 Izeja: 
a = b: 10 
 a + = b: 20 
 a - = b: 10
Tie bija dažādi operatori. Tagad turpināsim izmantot mūsu TypeScript apmācību un uzzināt par cilpām.
 Cilpas 
Var būt situācijas, kad koda bloku nepieciešams izpildīt vairākas reizes. A cilpa paziņojums ļauj mums izpildīt paziņojumu vai pārskatu grupu vairākas reizes.
TypeScript cilpas var klasificēt kā:
 Par cilpu 
The par cilpu ir noteiktas cilpas ieviešana.
 Sintakse: 
par (pirmā izteiksme otrā izteiksme trešā izteiksme) {// atkārtoti izpildāmi priekšraksti}
Šeit pirmā izteiksme tiek izpildīta pirms cilpas sākuma. Otrā izteiksme ir nosacījums, lai cilpa tiktu izpildīta. Trešā izteiksme tiek izpildīta pēc katra koda bloka izpildes.
 Piemērs: 
par (lai i = 0 i<2 i++) { console.log ('Execute block statement' + i) }
 Izeja: 
Izpildīt bloka paziņojumu 0 
Izpildīt 1. bloka paziņojumu
 Kamēr cilpa 
Kaut cikls izpilda instrukcijas katru reizi, kad norādītais nosacījums tiek vērtēts kā patiess.
 Sintakse: 
while (nosacījuma izteiksme) {// izpildāms koda bloks}
 Piemērs: 
ļaujiet man i: skaitlis = 1, kamēr (i<3) { console.log( 'Block statement execution no.' + i ) i++ }
 Izeja: 
Bloka izraksta izpilde Nr.1 
Bloka izraksta izpilde Nr.2
 Dariet .. Kamēr cilpa 
Do & hellipwhile cilpa ir līdzīga while ciklam, izņemot to, ka tā nenovērtē nosacījumu pirmo reizi, kad cilpa izpilda.
 Sintakse: 
do {// koda bloks, kas jāizpilda}, kamēr (nosacījuma izteiksme)
 Piemērs: 
  
ļaujiet man i: skaitlis = 1 darīt {console.log ('Bloķēt priekšraksta izpildes nr.' + i) i ++}, kamēr (i<3)
 Izeja: 
Bloka izraksta izpilde Nr.1 
Bloka izraksta izpilde Nr.2
Papildus tiem ir pārtraukuma un turpināšanas paziņojumi TypeScript, kas tiek izmantoti lokā.
 Pārtraukuma paziņojums 
Pārtraukuma paziņojumu izmanto, lai kontrolētu konstrukciju. Pārtraukuma paziņojuma izmantošana kontā palīdz programmai iziet no cilpas.
 Piemērs: 
var i: skaitlis = 1, kamēr (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
 Izeja: 
Pirmais 5 reizinājums no 1 līdz 10 ir: 5
 Turpināt paziņojumu 
Izraksts Continue izlaiž nākamos apgalvojumus pašreizējā atkārtojumā un pārņem vadību atpakaļ cikla sākumā.
 Piemērs: 
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)
 Izeja: 
Nepāra vērtību skaits no 0 līdz 10 ir: 5
Tās bija dažādas TypeScript cilpas. Tagad turpināsim izmantot mūsu TypeScript apmācību un izprast funkcijas.
 Funkcijas 
JavaScript valodā funkcijas ir viena no vissvarīgākajām daļām, jo ​​tā ir funkcionāla programmēšanas valoda. Funkcijas nodrošina programmas uzturēšanu un atkārtotu lietošanu un sakārtošanu lasāmos blokos. Lai gan TypeScript nodrošina klašu un moduļu jēdzienu, funkcijas joprojām ir neatņemama valodas sastāvdaļa.
 Nosauktās funkcijas 
Nosaukta funkcija tiek izmantota, lai deklarētu un izsauktu funkciju ar tās vārdu.
 Piemērs: 
funkciju displejs () {console.log ('TypeScript Function')} displejs ()
 Izeja: 
TypeScript funkcija
 Anonīma funkcija 
Anonīma funkcija ir tā, kuru definē kā izteiksmi. Šī izteiksme tiek saglabāta mainīgajā. Šīs funkcijas tiek izsauktas, izmantojot mainīgā nosaukumu, kurā funkcija ir saglabāta.
 Piemērs: 
ļaujiet sveicienam = function () {console.log ('TypeScript Function')} sveiciens ()
 Izeja: 
TypeScript funkcija
 Bultas funkcija 
Tauku bultiņu apzīmējumi tiek izmantoti anonīmām funkcijām, t.i., funkciju izteiksmēm. Citās valodās tās sauc arī par lambda funkcijām.
 Sintakse: 
(param1, param2, ..., paramN) => izteiksme
Izmantojot tauku bultiņu (=>), vairs nav nepieciešams izmantot atslēgas vārdu “function”. Parametri tiek nodoti leņķa iekavās, un funkcijas izteiksme ir ievietota cirtainajās iekavās {}.
 Piemērs: 
ļaujiet summa = (x: skaitlis, y: skaitlis): skaitlis => {atgriešanās x + y} summa (10, 30) // atgriež 40
 Funkcija Pārslodze 
TypeScript nodrošina funkciju pārslodzes jēdzienu. Tādējādi jums var būt vairākas funkcijas ar tādu pašu nosaukumu, bet dažādiem parametru tipiem un atgriešanās tipu.
 Piemērs: 
function add (a: string, b: string): string function add (a: number, b: number): number return a + b} add ('Hello', 'Edureka') // atgriež 'Hello Edureka' add ( 10, 10) // atgriež 20
Iepriekš minētajā piemērā mums ir viena un tā pati funkcija add () ar divām funkciju deklarācijām un vienu funkciju ieviešanu. Pirmajam parakstam ir divi tipa virknes parametri, bet otrajam parakstam ir divi tipa numura parametri.
Tie ir dažāda veida funkcijas. Tagad turpināsim izmantot mūsu TypeScript apmācību un izprast virknes TypeScript.
 TypeScript apmācība: virknes 
The  ir vēl viens primitīvs datu tips, ko izmanto teksta datu glabāšanai. Virknes vērtības ieskauj vienas pēdiņas vai divkāršās pēdiņas.
 Sintakse: 
var var_name = jauna virkne (virkne)
String objektā ir pieejamas dažādas metožu īpašības, piemēram:
 Celtnieks - Tas atgriež atsauci uz funkciju String, kas izveidoja objektu
 Garums - Tas atgriež virknes garumu
 Prototips - Šis rekvizīts ļauj objektam pievienot īpašības un metodes
 Piemērs: 
let name = new String ('Laipni lūdzam Edureka!') console.log ('Ziņojums:' + vārds) console.log ('Garums:' + nosaukums.length)
 Izeja: 
Ziņojums: Laipni lūdzam Edurekā! 
 Garums: 19
 Stīgu metodes 
Stringu objektā esošo metožu saraksts ietver:
 Metode 
 Apraksts 
 charAt () 
Tas atgriež rakstzīmi norādītajā indeksā
 charCodeAt () 
Tas atgriež skaitli, kas norāda rakstzīmes Unicode vērtību dotajā indeksā
 concat () 
Apvieno divu virkņu tekstu un atgriež jaunu virkni
 indexOf () 
Atgriež indeksu izsaucošās virknes objektā pēc pirmās norādītās vērtības parādīšanās
 lastIndexOf () 
Tas atgriež indeksu zvanošās virknes objektā pēc pēdējās norādītās vērtības parādīšanās
 spēles () 
Izmanto, lai regulāro izteiksmi saskaņotu ar virkni
 localeCompare () 
Atgriež skaitli, kas norāda, vai atsauces virkne nāk pirms vai pēc, vai ir tāda pati kā dotā virkne kārtošanas secībā
 Meklēt() 
Tas veic atbilstības meklēšanu starp regulāru izteiksmi un norādītu virkni
 aizvietot() 
Izmanto, lai atrastu atbilstību starp regulāru izteiksmi un virkni, kā arī lai aizstātu saskaņoto apakšvirkni ar jaunu apakšvirsrakstu
 šķēle () 
Tas izvelk virknes sadaļu un atgriež jaunu virkni
 sadalīt () 
String objektu sadala virkņu masīvā, atdalot virkni apakšvirsrakstos
 substr () 
Atgriež rakstzīmes virknē, sākot no norādītās vietas, izmantojot norādīto rakstzīmju skaitu
 apakšvirkne () 
Tas virknē atstāj rakstzīmes virknē starp diviem rādītājiem
 toLocaleLowerCase () 
Virknes rakstzīmes tiek pārvērstas par mazajiem burtiem, vienlaikus ievērojot pašreizējo lokalizāciju
 toLocaleUpperCase () 
Rakstzīmes virknē tiek pārveidotas par lielajiem burtiem, vienlaikus ievērojot pašreizējo lokalizāciju
 toLowerCase () 
Tas atgriež izsaucošās virknes vērtību, kas konvertēta ar mazajiem burtiem
 toUpperCase () 
Tas atgriež izsaucošās virknes vērtību, kas pārveidota par lielo burtu
 toString () 
Atgriež virkni, kas attēlo norādīto objektu
 valueOf () 
Atgriež norādītā objekta primitīvo vērtību
 Piemērs: 
let str: string = 'Laipni lūdzam Edureka' str.charAt (0) // atgriež 'w' str.charAt (2) // atgriež 'l' 'Laipni lūdzam Edureka'. : string = 'welcome' let str2: string = 'Edureka' str1.concat (str2) // atgriež 'welcomeEdureka' str1.concat ('', str2) // atgriež 'welcome Edureka' str1.concat ('' uz ' ') // atgriež' welcome to '
Tagad, kad jūs zināt par virknēm, turpināsim izmantot šo TypeScript apmācību un izprast masīvus.
 Masīvi TypeScript 
An masīvs ir īpaša veida datu tips, kas secīgi saglabā vairākas dažādu veidu datu vērtības, izmantojot īpašu sintaksi. Masīvu elementus identificē ar unikālu veselu skaitli, ko sauc par elementa indeksu vai indeksu.
 Sintakse: 
var masīva_nosaukums [: datatips] // deklarācija masīva_nosaukums = [val1, val2, valn ..] // inicializācija
 Piemērs: 
ļaujiet nosaukumiem: masīva nosaukumi = ['Džons', 'Daisy', 'Reičela]] let ids: Masīva ID = [101, 700, 321]
 Masīvu metodes 
Šeit ir saraksts ar dažādām masīva metodēm, kuras var izmantot dažādiem mērķiem:
 Metode 
 Apraksts 
 filtrs () 
Izveido jaunu masīvu ar visiem šī masīva elementiem, kuriem sniegtā filtrēšanas funkcija atgriež patieso vērtību
 katrs() 
Atgriež vērtību true, ja visi šī masīva elementi atbilst paredzētajai testēšanas funkcijai
 concat () 
Atgriež jaunu masīvu, kas sastāv no šī masīva un savienots ar citiem masīviem
 indexOf () 
Atgriež masīva elementa pirmo vai mazāko indeksu, kas vienāds ar norādīto vērtību
 katram() 
Izsauc funkciju katram masīva elementam
 pievienoties () 
Apvieno visus masīva elementus virknē
 lastIndexOf () 
Atgriež masīva elementa pēdējo vai lielāko indeksu, kas vienāds ar norādīto vērtību
 karte () 
ko ide izmantot java
Izveido jaunu masīvu ar rezultātiem, izsaucot paredzēto funkciju katram šī masīva elementam
 virzīt () 
Masīva beigās pievieno vienu vai vairākus elementus un atgriež masīva jauno garumu
 pop () 
Noņem masīva pēdējo elementu un atgriež šo elementu
 samazināt () 
Vienlaicīgi lietojiet funkciju pret divām masīva vērtībām no kreisās uz labo, lai samazinātu to līdz vienai vērtībai
 samazinātRight () 
Lietojiet funkciju vienlaikus pret divām masīva vērtībām no labās uz kreiso pusi, lai samazinātu to līdz vienai vērtībai
 reverss () 
Apgriež masīva elementu secību
 maiņa () 
Noņem masīvu pirmo elementu un atgriež šo elementu
 šķēle () 
Izvelk masīva sadaļu un atgriež jaunu masīvu
 daži () 
Tas atgriež vērtību true, ja vismaz viens šī masīva elements atbilst paredzētajai testēšanas funkcijai
 kārtot () 
Tas kārto masīva elementus
 toString () 
Atgriež virkni, kas attēlo masīvu un tā elementus
 savienojums () 
Tas pievieno un / vai noņem elementus no masīva
 atcelt () 
Masīva priekšā pievieno vienu vai vairākus elementus un atgriež masīva jauno garumu
 Piemērs: 
var name: Array = ['John', 'Daisy', 'Tara'] name.sort () console.log (name) // output: ['Daisy', 'John', 'Tara'] console.log ( name.pop ()) // output: Tara name.push ('Rachel') console.log (name) // output: ['John', 'Daisy', 'Rachel']
Tagad ejam uz priekšu ar šo TypeScript apmācību un uzzinām par saskarnēm.
 TypeScript saskarnes 
Interfeiss ir struktūra, kas nosaka līgumu jūsu lietojumprogrammā. Tas nosaka sintaksi, kas jāievēro klasēm. Tajā ir tikai dalībnieku deklarācija, un locekļu noteikšana ir atvasinātās klases atbildība.
 Piemērs: 
saskarne Darbinieks {empID: numurs empName: virkne getSalary: (skaitlis) => skaitlis // bultiņas funkcija getManagerName (numurs): virkne}
Iepriekš minētajā piemērā Darbinieks interfeiss ietver divas īpašības empID un empName . Tas ietver arī metodes deklarāciju getSalaray izmantojot bultiņas funkcija kas ietver vienu skaitļa parametru un skaitļa atgriešanas veidu. The getManagerName metodi deklarē, izmantojot parasto funkciju.
 TypeScript  Klases 
TypeScript ieviesa klases, lai tās varētu izmantot objektorientētu paņēmienu, piemēram, iekapsulēšanas un abstrakcijas, priekšrocības. TypeScript kompilators TypeScript klasi apkopo vienkāršās JavaScript funkcijās, lai darbotos dažādās platformās un pārlūkprogrammās.
Klasē ietilpst:
 Celtnieks 
 Rekvizīti 
 Metodes 
 Piemērs: 
klases darbinieks {empID: numurs empName: virknes konstruktors (ID: numurs, nosaukums: virkne) {this.empName = nosaukums this.empID = ID} getSalary (): numurs {return 40000}}
 Mantojums 
TypeScript atbalsta Mantojums jo tā ir programmas spēja izveidot jaunas klases no esošās klases. Klase, kas tiek paplašināta, lai izveidotu jaunākas klases, tiek dēvēta par vecāku klasi vai super klasi. Jaunizveidotās klases sauc par bērnu vai apakšklasēm.
Klase manto no citas klases, izmantojot atslēgvārdu ‘paplašina’. Bērnu klases pārņem visas īpašības un metodes, izņemot privātus dalībniekus un konstruktorus no vecāku klases. Bet, TypeScript neatbalsta vairāku mantojumu.
 Sintakse: 
klase child_class_name paplašina parent_class_name
 Piemērs: 
klase Persona {nosaukums: virknes konstruktors (nosaukums: virkne) {this.name = nosaukums}} klase Darbinieks pagarina personu (): void {console.log ('Name =' + this.name + ', Employee ID =' + this.empID)}} let emp = new Employee (701, 'Jason') emp.displayName () // Vārds = Džeisons, darbinieka ID = 701
Tagad, kad jūs zināt par klasēm, pārejiet uz priekšu ar šo TypeScript apmācību un uzziniet par objektiem.
 Objekti TypeScript 
Objekts ir gadījums, kas satur citu atslēgu un vērtību pāru kopu. Vērtības var būt skalāras vērtības vai funkcijas vai pat citu objektu masīvs.
 Sintakse: 
var objekta_nosaukums = {atslēga1: “vērtība1”, // skalārās vērtības atslēga2: “vērtība”, atslēga3: funkcija () {// funkcijas}, atslēga4: [“saturs1”, “saturs2”]
Objekts var saturēt skalāras vērtības, funkcijas un struktūras, piemēram, masīvus un kopas.
 Piemērs: 
var person = {vārds: 'Danny', uzvārds: 'Green'} // piekļūstiet objekta vērtībām console.log (person.firstname) console.log (person.lastname)
Apkopojot, tas ģenerēs to pašu kodu JavaScript.
 Izeja: 
Denijs 
 Zaļš
Tie bija dažādi svarīgie TypeScript elementi. Tagad turpināsim šo TypeScript apmācību un apskatīsim piemēru, lai saprastu lietošanas gadījumu.
 TypeScript apmācība: lietojuma gadījums 
Šeit mēs uzzināsim, kā pārveidot esošu  uz TypeScript.
Kad mēs apkopojam TypeScript failu, tas rada atbilstošu JavaScript failu ar tādu pašu nosaukumu. Šeit mums jānodrošina, lai mūsu sākotnējais JavaScript fails, kas darbojas kā ievade, nevar atrasties tajā pašā direktorijā, lai TypeScript tos nepārvarētu.
Pārejas process no JavaScript uz TypeScript ietver šādas darbības:
 1. Pievienojiet projektam failu tsconfig.json 
Projektam jāpievieno fails tsconfig.json. TypeScript izmanto failu tsconfig.json, lai pārvaldītu projekta kompilēšanas opcijas, piemēram, kurus failus vēlaties iekļaut un izslēgt.
{'compilerOptions': {'outDir': './built', 'allowJs': true, 'target': 'es5'}, 'include': ['./src/**/*']}
 2. Integrējiet ar būvēšanas rīku 
Lielākajai daļai JavaScript projektu ir integrēts veidošanas rīks, piemēram, gulp vai webpack. Projektus ar webpack var integrēt šādos veidos:
Izpildiet šādu komandu terminālā:
$ npm instalējiet awesome-typcript-loader source-map-loader
Webpack integrācijā jūs izmantojat lielisku-typcript-loader kopā ar source-map-loader, lai vieglāk atkļūdotu avota kodu.
Otrkārt, apvienojiet moduļa config rekvizītu mūsu failā webpack.config.js, lai iekļautu iekrāvējus.
 3. Pārvietojiet visus .js failus uz .ts failiem 
Šajā solī jums jāpārdēvē .js fails par .ts failu. Līdzīgi, ja failā tiek izmantots JSX, tas būs jāpārsauc par .tsx. Tagad, ja mēs atveram šo failu redaktorā, kas atbalsta TypeScript, daži kodi var sākt radīt kompilācijas kļūdas. Tātad, failu konvertēšana pa vienam ļauj vieglāk apstrādāt kompilēšanas kļūdas. Ja TypeScript konvertēšanas laikā atrod kādas kompilācijas kļūdas, tas joprojām var tulkot kodu.
 4. Pārbaudiet, vai nav kļūdu 
Pēc js faila pārvietošanas uz ts failu nekavējoties TypeScript sāks mūsu koda tipa pārbaudi. Tātad JavaScript kodā var rasties diagnostikas kļūdas.
 5. Izmantojiet trešo pušu JavaScript bibliotēkas 
JavaScript projektos tiek izmantotas trešo pušu bibliotēkas, piemēram,  vai Lodash. Lai kompilētu failus, TypeScript ir jāzina visu šo bibliotēku objektu tipi. JavaScript bibliotēku TypeScript tipa definīcijas faili jau ir pieejami vietnē DefinitelyTyped. Tātad, nav nepieciešams instalēt šo tipu ārēji. Jums jāinstalē tikai tie veidi, kas tiek izmantoti mūsu projektā.
JQuery varat instalēt definīciju:
$ npm instalēt @ tips / jquery
Pēc tam veiciet izmaiņas JavaScript projektā, palaidiet veidošanas rīku. Tagad jums vajadzētu būt TypeScript projektam, kas apkopots vienkāršā JavaScript valodā, kuru var palaist pārlūkprogrammā.
Ar to mēs esam nonākuši šajā TypeScript apmācībā. Es ceru, ka jūs sapratāt visus svarīgos TypeScript elementus.
 Pārbaudiet     autore Edureka.  Tīmekļa attīstības sertifikācijas apmācība palīdzēs jums uzzināt, kā izveidot iespaidīgas vietnes, izmantojot HTML5, CSS3, Twitter Bootstrap 3, jQuery un Google API, un izvietot to Amazon Simple Storage Service (S3). 
 Vai mums ir jautājums? Lūdzu, pieminējiet to komentāru sadaļā “TypeScript apmācība”, un mēs ar jums sazināsimies.