Výukový program pro strojopis: Získejte informace o základech strojopisu

TypeScript je silně napsaná nadmnožina který se kompiluje do prostého JavaScriptu. Tento jazyk můžete použít pro vývoj JavaScriptu v měřítku aplikace. Lze jej také spustit v libovolném prohlížeči, libovolném hostiteli a libovolném operačním systému. V tomto výukovém programu pro strojopis se dostaneme do hloubky strojopisu a porozumíme základům v následující posloupnosti:

• Úvod do strojopisu
• Typy strojopisu
• Proměnné
• Operátoři
• Smyčky
• Funkce
• Struny
• Pole
• Rozhraní
• Třídy
• Objekty
• Případ použití TypeScript

Úvod do strojopisu

TypeScript je typová nadmnožina JavaScriptu, která se kompiluje s prostým JavaScriptem. TypeScript je čistě objektově orientovaný s takovými třídami, rozhraními a staticky napsanými programovacími jazyky C # nebo . K kompilaci a generování v souboru JavaScript vyžaduje kompilátor. TypeScript je v zásadě ES6 verze JavaScriptu s některými dalšími funkcemi.

Kód TypeScript je zapsán do souboru s přípona .ts a poté pomocí kompilátoru zkompilován do JavaScriptu. Soubor můžete napsat v libovolném editoru kódu a kompilátor je třeba nainstalovat na vaši platformu. Po instalaci příkaz tsc. ts zkompiluje kód TypeScript do prostého souboru JavaScriptu.

Syntax:

var message: string = 'Vítejte v Edurece!' console.log (zpráva)

Při kompilaci generuje následující kód JavaScript:

// Generováno strojopisem 1.8.10 var message = 'Vítejte v Edurece!' console.log (zpráva)

Vlastnosti strojopisu

• Cross-Platform: Kompilátor TypeScript lze nainstalovat na jakýkoli operační systém, jako je Windows, MacOS a Linux.

  
  
  

• Objektově orientovaný jazyk : TypeScript poskytuje funkce jako Třídy , Rozhraní a Moduly. Může tedy psát objektově orientovaný kód pro vývoj na straně klienta i serveru.

• Statická kontrola typu : TypeScript používá statické psaní a pomáhá kontrolovat psaní v době kompilace. Můžete tedy najít chyby při psaní kódu bez spuštění skriptu.

• Volitelné statické psaní : TypeScript také umožňuje volitelné statické psaní v případě, že používáte dynamické psaní JavaScriptu.

• Manipulace s DOM : Můžete použít TypeScript k manipulaci s DOM pro přidávání nebo odebírání prvků.

• Funkce ES 6 : TypeScript obsahuje většinu funkcí plánovaného ECMAScript 2015 (ES 6, 7), jako je třída, rozhraní, funkce šipek atd.

Výhody používání TypeScript

• Strojopis je rychlé, jednoduché, snadno se učí a běží na jakémkoli prohlížeči nebo enginu JavaScriptu.

• to je podobný na JavaScript a používá stejnou syntaxi a sémantiku.

• To pomáhá vývojářům back-endu psát front-end kód rychleji .

• Kód strojopisu lze volat z existující kód JavaScript . Bez problémů funguje také s existujícími rámci a knihovnami JavaScriptu.

• Soubor Definice s příponou .d.ts poskytuje podporu pro existující knihovny JavaScriptu jako Jquery, D3.js atd. Kód TypeScript tedy lze přidat Knihovny JavaScript použití definic typů k využití výhod kontroly typu, automatického doplňování kódu a dokumentace ve stávajících dynamicky zadávaných knihovnách JavaScriptu.

• Zahrnuje funkce z ES6 a ES7 které mohou běžet v motorech JavaScript na úrovni ES5 Node.js .

Nyní, když jste pochopili, co je TypeScript, pojďme se podívat na tento tutoriál TypeScript a podívejme se na různé typy.

Typy strojopisu

Typový systém představuje různé typy hodnot podporovaných jazykem. Kontroluje to platnost dodaného hodnoty před tím, než je program uloží nebo s nimi manipuluje.

Lze jej rozdělit do dvou typů, například:

• Vestavěný : To zahrnuje number, string, boolean, void, null and undefined.
• Definováno uživatelem : Zahrnuje výčty (výčty), třídy, rozhraní, pole a n-tici.

Pojďme nyní s tímto výukovým programem TypeScript a pochopme více o proměnných.

Výukový program pro strojopis: Proměnné

Proměnná je pojmenovaný prostor v paměti, který se používá k ukládání hodnot.

Syntaxe typu pro deklarování proměnné v TypeScriptu obsahuje dvojtečku (:) za názvem proměnné, následovanou jejím typem. Podobně jako u JavaScriptu používáme var klíčové slovo deklarovat proměnnou.

Když deklarujeme proměnnou, existují čtyři možnosti:

var [identifikátor]: [anotace typu] = hodnota

var [identifikátor]: [anotace typu]

var [identifikátor] = hodnota

var [identifikovat]

Příklad:

var name: string = 'Daisy' var empid: number = 1001 console.log ('name' + name) console.log ('id zaměstnance' + empid)

Při kompilaci vygeneruje následující kód JavaScript:

// Generováno strojopisem 1.8.10 var name = 'Daisy' var empid = 1001 console.log ('name' + name) console.log ('employee id:' + empid)

Výstup:

jméno: Daisy
id zaměstnance: 1001

Nyní přejdeme k dalšímu tématu našeho Výukového programu pro strojopis.

Operátoři

Operátor se používá k definování funkcí, které se budou na datech provádět. Data, na kterých operátoři pracují, se nazývají operandy. Existují různé typy operátory v TypeScript, jako například:

• Aritmetické operátory
• Logické operátory
• Relační operátoři
• Bitové operátory
• Operátoři přiřazení

Aritmetické operátory

Příklad:

var num1: number = 10 var num2: number = 2 var res: number = 0 res = num1 + num2 console.log ('Sum:' + res) res = num1 - num2 console.log ('Rozdíl:' + res) res = num1 * num2 console.log ('Product:' + res)

Výstup:

Součet: 12
Rozdíl: 8
Produkt: 20

Logičtí operátoři

Příklad:

var avg: number = 20 var percent: number = 90 console.log ('Hodnota avg:' + avg + ', hodnota procenta:' + procento) var res: boolean = ((avg> 50) && (procento> 80 )) console.log ('(avg> 50) && (procento> 80):', res)

Výstup:

Hodnota průměru: 20, hodnota v procentech: 90
(průměr> 50) && (procento> 80): nepravdivé

Relační operátoři

Příklad:

var num1: number = 10 var num2: number = 7 console.log ('Hodnota num1:' + num1) console.log ('Hodnota num2:' + num2) var res = num1> num2 console.log ('num1 větší než num2: '+ res) res = num1
 Výstup: 
Hodnota num1: 10 
 Hodnota num2: 7 
 num1 větší než num2: true 
 num1 menší než num2: false
 Bitové operátory 
 Operátoři 
 Popis 
 Bitový AND (&) 
provede logickou operaci AND na každém bitu jeho celočíselných argumentů.
 Bitový OR (|) 
Provádí logickou operaci OR na každém bitu svých celočíselných argumentů.
 Bitový XOR (^) 
Provádí booleovskou exkluzivní operaci OR na každém bitu svých celočíselných argumentů.
 Bitový NOT (~) 
Toto je unární operátor a pracuje obrácením všech bitů v operandu.
 Levý Shift (<<) 
Přesune všechny bity ve svém prvním operandu doleva o počet míst určených ve druhém operandu.
java cast řetězec k dnešnímu dni
 Pravý Shift (>>) 
Hodnota levého operandu se posune doprava o počet bitů určený pravým operandem.
 Right Shift with Zero (>>>) 
Je to podobné jako >> operátor, až na to, že bity posunuté vlevo jsou vždy nula.
 Příklad: 
var a: number = 2 // Bitová prezentace 10 var b: number = 3 // Bitová prezentace 11 var result result = (a & b) console.log ('(a & b) =>', result) result = ( a | b) console.log ('(a | b) =>', výsledek)
 Výstup: 
(a & b) => 2 
 (a | b) => 3
 Operátoři přiřazení 
 Operátoři 
 Popis 
 Jednoduché přiřazení (=) 
Přiřadí hodnoty z operandu na pravé straně operandu na levé straně
 Přidat a přiřadit (+ =) 
Přidá pravý operand k levému operandu a přiřadí výsledek levému operandu.
 Odečíst a přiřadit (- =) 
Odečte pravý operand od levého operandu a výsledek přiřadí levému operandu.
 Násobení a přiřazení (* =) 
Násobí pravý operand levým operandem a přiřadí výsledek levému operandu.
 Rozdělení a přiřazení (/ =) 
Rozdělí levý operand na pravý operand a přiřadí výsledek levému operandu.
 Příklad: 
var a: number = 12 var b: number = 10 a = b console.log ('a = b:' + a) a + = b console.log ('a + = b:' + a) a - = b konzole .log ('a- = b:' + a)
 Výstup: 
a = b: 10 
 a + = b: 20 
 a - = b: 10
To byli různí operátoři. Pojďme nyní s naším výukovým programem TypeScript a naučme se smyčky.
 Smyčky 
Mohou nastat situace, kdy je třeba blok kódu provést několikrát. A smyčka statement nám umožňuje provést příkaz nebo skupinu výpisů několikrát.
Smyčky TypeScript lze klasifikovat jako:
 Pro smyčku 
The pro smyčku je implementace určité smyčky.
 Syntax: 
for (první výraz druhý výraz třetí výraz) {// příkazy, které se mají provádět opakovaně}
Zde je první výraz proveden před spuštěním smyčky. Druhý výraz je podmínkou pro provedení smyčky. A třetí výraz se provede po provedení každého bloku kódu.
 Příklad: 
pro (nechť i = 0 i<2 i++) { console.log ('Execute block statement' + i) }
 Výstup: 
Proveďte příkaz bloku 0 
Proveďte příkaz bloku 1
 Zatímco Loop 
Smyčka while provede pokyny pokaždé, když se zadaná podmínka vyhodnotí jako true.
 Syntax: 
while (podmínkový výraz) {// blok kódu, který má být proveden}
 Příklad: 
ať i: number = 1 while (i<3) { console.log( 'Block statement execution no.' + i ) i++ }
 Výstup: 
Blokové provedení příkazu č. 1 
Blokové provedení příkazu č. 2
 Do..While Loop 
Smyčka do & hellipwhile je podobná smyčce while, kromě toho, že nevyhodnocuje podmínku při prvním provedení smyčky.
 Syntax: 
do {// blok kódu, který má být proveden} while (výraz podmínky)
 Příklad: 
  
let i: number = 1 do {console.log ('Block statement execution no.' + i) i ++} while (i<3)
 Výstup: 
Blokové provedení příkazu č. 1 
Blokové provedení příkazu č. 2
Kromě těchto existují příkazy break and continue v TypeScript, které se používají ve smyčce.
 Prohlášení o přestávce 
Příkaz break se používá k převzetí kontroly z konstrukce. Použití příkazu break ve smyčce pomáhá programu při opuštění smyčky.
 Příklad: 
var i: číslo = 1 while (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
 Výstup: 
První násobek 5 mezi 1 a 10 je: 5
 Pokračovat v prohlášení 
Příkaz continue přeskočí následující příkazy v aktuální iteraci a vezme ovládací prvek zpět na začátek smyčky.
 Příklad: 
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)
 Výstup: 
Počet lichých hodnot mezi 0 a 10 je: 5
Jednalo se o různé smyčky v TypeScript. Pojďme nyní s naším Výukem strojopisu a porozumíme funkcím.
 Funkce 
V JavaScriptu funkce jsou jednou z nejdůležitějších částí, protože se jedná o funkční programovací jazyk. Funkce zajišťují, že program je udržovatelný a opakovaně použitelný a organizovaný do čitelných bloků. Zatímco TypeScript poskytuje koncept tříd a modulů, funkce jsou stále nedílnou součástí jazyka.
 Pojmenované funkce 
Pojmenovaná funkce se používá k deklaraci a volání funkce podle jejího křestního jména.
 Příklad: 
function display () {console.log ('TypeScript Function')} display ()
 Výstup: 
Funkce strojopisu
 Anonymní funkce 
Anonymní funkce je funkce, která je definována jako výraz. Tento výraz je uložen v proměnné. Tyto funkce jsou vyvolány pomocí názvu proměnné, ve které je funkce uložena.
 Příklad: 
let pozdrav = funkce () {console.log ('funkce TypeScript')} pozdrav ()
 Výstup: 
Funkce strojopisu
 Funkce šipky 
Značky tlusté šipky se používají pro anonymní funkce, tj. Pro výrazy funkcí. V jiných jazycích se jim také říká funkce lambda.
 Syntax: 
(param1, param2, ..., paramN) => výraz
Použitím tlusté šipky (=>) klesá potřeba používat klíčové slovo „function“. Parametry jsou předávány v hranatých závorkách a výraz funkce je uzavřen v složených závorkách {}.
 Příklad: 
let sum = (x: number, y: number): number => {return x + y} sum (10, 30) // returns 40
 Přetížení funkce 
TypeScript poskytuje koncept přetížení funkce. Můžete tedy mít více funkcí se stejným názvem, ale s různými typy parametrů a návratovým typem.
 Příklad: 
funkce add (a: string, b: string): string funkce add (a: number, b: number): number return a + b} add ('Hello', 'Edureka') // returns 'Hello Edureka' add ( 10, 10) // vrátí 20
Ve výše uvedeném příkladu máme stejnou funkci add () se dvěma deklaracemi funkcí a jednou implementací funkce. První podpis má dva parametry typového řetězce, zatímco druhý podpis má dva parametry čísla typu.
Jedná se o různé typy funkcí. Pojďme nyní s naším výukovým programem TypeScript a pochopme řetězce v TypeScript.
 Výukový program pro strojopis: Řetězce 
The  je další primitivní datový typ, který se používá k ukládání textových dat. Řetězcové hodnoty jsou obklopeny jednoduchými uvozovkami nebo dvojitými uvozovkami.
 Syntax: 
var var_name = nový řetězec (řetězec)
V objektu String jsou k dispozici různé vlastnosti metod, například:
 Stavitel - Vrátí odkaz na funkci String, která objekt vytvořila
 Délka - Tím se vrátí délka řetězce
 Prototyp - Tato vlastnost umožňuje přidat do objektu vlastnosti a metody
 Příklad: 
let name = new String ('Welcome to Edureka!') console.log ('Message:' + name) console.log ('Length:' + name.length)
 Výstup: 
Zpráva: Vítejte v Edurece! 
 Délka: 19
 Řetězcové metody 
Seznam metod v řetězcovém objektu zahrnuje:
 Metoda 
 Popis 
 charAt () 
Vrátí znak v zadaném indexu
 charCodeAt () 
Vrátí číslo označující hodnotu Unicode znaku v daném indexu
 concat () 
Zkombinuje text dvou řetězců a vrátí nový řetězec
 indexOf () 
Vrátí index v rámci volajícího objektu String prvního výskytu zadané hodnoty
 lastIndexOf () 
Vrátí index v rámci volajícího objektu String posledního výskytu zadané hodnoty
 zápas() 
Slouží k porovnání regulárního výrazu s řetězcem
 localeCompare () 
Vrátí číslo označující, zda referenční řetězec přichází před nebo po nebo je stejný jako daný řetězec v pořadí řazení
 Vyhledávání() 
Tím se spustí hledání shody mezi regulárním výrazem a zadaným řetězcem
 nahradit() 
Slouží k nalezení shody mezi regulárním výrazem a řetězcem ak nahrazení shodného podřetězce novým podřetězcem
 plátek() 
Extrahuje část řetězce a vrátí nový řetězec
 rozdělit() 
Rozdělí objekt String na pole řetězců oddělením řetězce na podřetězce
 substr () 
Vrátí znaky v řetězci začínající na zadaném místě prostřednictvím zadaného počtu znaků
 podřetězec () 
Vrátí znaky v řetězci mezi dvěma indexy do řetězce
 toLocaleLowerCase () 
Znaky v řetězci jsou převedeny na malá písmena při respektování aktuálního národního prostředí
 toLocaleUpperCase () 
Znaky v řetězci jsou převedeny na velká písmena při respektování aktuálního národního prostředí
 toLowerCase () 
Vrátí hodnotu volajícího řetězce převedenou na malá písmena
 toUpperCase () 
Vrátí hodnotu volajícího řetězce převedenou na velká písmena
 toString () 
Vrátí řetězec představující zadaný objekt
 hodnota() 
Vrátí primitivní hodnotu zadaného objektu
 Příklad: 
let str: string = 'Vítejte v Edurece' str.charAt (0) // vrací 'w' str.charAt (2) // vrací 'l' 'Vítejte v Edurece'. charAt (2) vrací 'l' let str1 : string = 'welcome' let str2: string = 'Edureka' str1.concat (str2) // vrací 'welcomeEdureka' str1.concat ('', str2) // vrací 'welcome Edureka' str1.concat ('' to ' ') // vrací „vítejte na“
Nyní, když víte o řetězcích, pojďme s tímto výukovým programem TypeScript a porozuměme polím.
 Pole v strojopisu 
An pole je speciální typ datového typu, který ukládá více hodnot různých datových typů postupně pomocí speciální syntaxe. Prvky pole jsou identifikovány jedinečným celým číslem nazývaným dolní index nebo index prvku.
 Syntax: 
var array_name [: datatype] // deklarace array_name = [val1, val2, valn ..] // inicializace
 Příklad: 
let names: Array names = ['John', 'Daisy', 'Rachel'] let ids: Array ids = [101, 700, 321]
 Pole metody 
Zde je seznam různých metod pole, které lze použít pro různé účely:
 Metoda 
 Popis 
 filtr() 
Vytvoří nové pole se všemi prvky tohoto pole, pro které zadaná funkce filtrování vrátí hodnotu true
 každý() 
Vrátí true, pokud každý prvek v tomto poli splňuje poskytnutou testovací funkci
 concat () 
Vrátí nové pole složené z tohoto pole spojené s jinými poli
 indexOf () 
Vrátí první nebo nejméně index prvku v rámci pole rovný zadané hodnotě
 pro každého() 
Volá funkci pro každý prvek v poli
 připojit se() 
Spojí všechny prvky pole do řetězce
 lastIndexOf () 
Vrátí poslední nebo největší index prvku v poli rovný zadané hodnotě
 mapa() 
Vytvoří nové pole s výsledky volání poskytované funkce u každého prvku v tomto poli
 tlačit() 
Přidá jeden nebo více prvků na konec pole a vrátí novou délku pole
 pop () 
Odebere poslední prvek z pole a vrátí tento prvek
 snížit() 
Použijte funkci současně proti dvěma hodnotám pole zleva doprava, abyste ji snížili na jednu hodnotu
 reduRight () 
Použijte funkci současně proti dvěma hodnotám pole zprava doleva, abyste ji snížili na jednu hodnotu
 zvrátit() 
Obrátí pořadí prvků pole
 posun() 
Odebere první prvek z pole a vrátí tento prvek
 plátek() 
Extrahuje část pole a vrátí nové pole
 nějaký() 
Vrátí true, pokud alespoň jeden prvek v tomto poli splňuje poskytnutou testovací funkci
 sort () 
Seřadí prvky pole
 toString () 
Vrátí řetězec představující pole a jeho prvky
co je keyerror v pythonu
 splice () 
Přidává a / nebo odstraňuje prvky z pole
 unshift () 
Přidá jeden nebo více prvků do přední části pole a vrátí novou délku pole
 Příklad: 
var name: Array = ['John', 'Daisy', 'Tara'] name.sort () console.log (name) // výstup: ['Daisy', 'John', 'Tara'] console.log ( name.pop ()) // výstup: Tara name.push ('Rachel') console.log (name) // výstup: ['John', 'Daisy', 'Rachel']
Nyní pojďme s tímto výukovým programem TypeScript a naučme se o rozhraních.
 Rozhraní strojopisu 
Rozhraní je struktura, která definuje smlouvu ve vaší aplikaci. Definuje syntaxi pro třídy, které mají následovat. Obsahuje pouze deklaraci členů a definici členů nese odpovědnost odvozující třída.
 Příklad: 
zaměstnanec rozhraní {empID: number empName: string getSalary: (number) => number // arrow function getManagerName (number): string}
Ve výše uvedeném příkladu Zaměstnanec rozhraní obsahuje dvě vlastnosti empID a empName . Zahrnuje také deklaraci metody getSalaray pomocí funkce šipky který obsahuje jeden číselný parametr a návratový typ čísla. The getManagerName metoda je deklarována pomocí normální funkce.
 Strojopis  Třídy 
TypeScript představil třídy, aby mohly využívat výhod objektově orientovaných technik, jako je zapouzdření a abstrakce. Třída v TypeScript je kompilována do běžných funkcí JavaScriptu kompilátorem TypeScript, aby fungovala napříč platformami a prohlížeči.
Třída zahrnuje následující:
 Stavitel 
 Vlastnosti 
 Metody 
 Příklad: 
třída Zaměstnanec {empID: číslo empName: konstruktor řetězce (ID: číslo, název: řetězec) {this.empName = jméno this.empID = ID} getSalary (): number {return 40000}}
 Dědictví 
Podporuje strojopis Dědictví protože jde o schopnost programu vytvářet nové třídy z existující třídy. Třída, která je rozšířena o vytvoření novějších tříd, se nazývá nadřazená třída nebo super třída. Nově vytvořené třídy se nazývají podřízené nebo podtřídy.
Třída dědí z jiné třídy pomocí klíčového slova „extends“. Podřízené třídy dědí všechny vlastnosti a metody kromě soukromých členů a konstruktorů z nadřazené třídy. TypeScript ale nepodporuje vícenásobné dědění.
 Syntax: 
třída child_class_name rozšiřuje parent_class_name
 Příklad: 
třída Osoba {name: string constructor (name: string) {this.name = name}} class Employee extends Person {empID: number constructor (empID: number, name: string) {super (name) this.empID = empid} displayName (): void {console.log ('Name =' + this.name + ', Employee ID =' + this.empID)}} let emp = new Employee (701, 'Jason') emp.displayName () // Jméno = Jason, ID zaměstnance = 701
Nyní, když víte o třídách, pojďme s tímto Výukem strojopisu a naučme se něco o objektech.
 Objekty v strojopisu 
Objekt je instance, která obsahuje jinou sadu párů klíč – hodnota. Hodnotami mohou být skalární hodnoty nebo funkce nebo dokonce řada dalších objektů.
 Syntax: 
var název_objektu = {klíč1: „hodnota1“, // skalární hodnota klíč2: „hodnota“, klíč3: funkce () {// funkce}, klíč4: [„obsah1“, „obsah2“]
Objekt může obsahovat skalární hodnoty, funkce a struktury, jako jsou pole a n-tice.
 Příklad: 
var person = {firstname: 'Danny', lastname: 'Green'} // přístup k hodnotám objektu console.log (person.firstname) console.log (person.lastname)
Při kompilaci vygeneruje stejný kód v JavaScriptu.
 Výstup: 
Danny 
 Zelený
To byly různé důležité prvky TypeScript. Pojďme nyní s tímto tutoriálem TypeScript a podívejme se na příklad, abychom pochopili případ použití.
 Výukový program pro strojopis: Použít případ 
Zde se naučíme, jak převést existující  do strojopisu.
Když kompilujeme soubor TypeScript, vytvoří odpovídající soubor JavaScript se stejným názvem. Zde musíme zajistit, aby náš původní soubor JavaScriptu, který funguje jako vstup, nemohl být ve stejném adresáři, aby je TypeScript nepřepsal.
Proces migrace z JavaScriptu do TypeScript zahrnuje následující kroky:
 1. Přidejte do projektu soubor tsconfig.json 
Musíte do projektu přidat soubor tsconfig.json. TypeScript používá soubor tsconfig.json pro správu možností kompilace projektu, například souborů, které chcete zahrnout a vyloučit.
{'compilerOptions': {'outDir': './built', 'allowJs': true, 'target': 'es5'}, 'include': ['./src/**/*']}
 2. Integrace s nástrojem pro sestavení 
Většina projektů JavaScriptu má integrovaný nástroj pro vytváření, jako je gulp nebo webpack. Projekty můžete integrovat do webového balíčku následujícími způsoby:
Na terminálu spusťte následující příkaz:
$ npm nainstalujte úžasný strojopisný zavaděč zdrojového mapového zavaděče
V integraci webového balíčku používáte pro snazší ladění zdrojového kódu úžasný zavaděč psacích strojů v kombinaci se zdrojovým mapovým zavaděčem.
Za druhé sloučte vlastnost konfigurace modulu v našem souboru webpack.config.js a zahrňte do něj zavaděče.
 3. Přesuňte všechny soubory .js do souborů .ts 
V tomto kroku musíte přejmenovat soubor .js na soubor .ts. Podobně, pokud soubor používá JSX, budete jej muset přejmenovat na .tsx. Nyní, pokud tento soubor otevřeme v editoru, který podporuje TypeScript, by některé z kódů mohly začít dávat chyby kompilace. Takže převádění souborů jeden po druhém umožňuje snadnější zpracování chyb kompilace. Pokud TypeScript najde během převodu nějaké chyby kompilace, je stále schopen přeložit kód.
 4. Zkontrolujte chyby 
Po přesunutí souboru js do souboru ts okamžitě TypeScript zahájí kontrolu typu našeho kódu. V kódu JavaScriptu se tedy mohou zobrazit diagnostické chyby.
 5. Používejte knihovny JavaScript třetích stran 
Projekty JavaScript používají knihovny třetích stran, jako je  nebo Lodash. Aby bylo možné kompilovat soubory, TypeScript potřebuje znát typy všech objektů v těchto knihovnách. Soubory definice TypeScript Type pro knihovny JavaScript jsou již k dispozici na DefinitelyTyped. Není tedy nutné tento typ instalovat externě. Musíte nainstalovat pouze ty typy, které jsou použity v našem projektu.
Pro jQuery můžete nainstalovat definici:
$ npm install @ types / jquery
Poté proveďte změny v projektu JavaScript, spusťte nástroj pro sestavení. Nyní byste měli mít projekt TypeScript zkompilovaný do prostého JavaScriptu, který lze spustit v prohlížeči.
S tímto jsme se dostali na konec tohoto TypeScript Tutorial. Doufám, že jste pochopili všechny důležité prvky TypeScript.
 Podívejte se na     podle Edureka.  Osvědčení o školení pro vývoj webových aplikací vám pomůže Naučte se, jak vytvářet působivé webové stránky pomocí HTML5, CSS3, Twitter Bootstrap 3, jQuery a Google API a jak je nasadit do služby Amazon Simple Storage Service (S3). 
 Máte na nás dotaz? Uveďte to prosím v sekci komentářů v „Výukovém stroji TypeScript“ a my se vám ozveme.