Mi az a TypeScript, és miért kellene azt használnom a JavaScript helyett?

Mi az a TypeScript nyelv? Mit tud, amit a JavaScript vagy a rendelkezésre álló könyvtárak nem tudnak, ami okot adna arra, hogy fontolóra vegyem?

Válasz #1

Eredetileg ezt a választ akkor írtam, amikor a TypeScript még friss volt. Öt évvel később ez egy egész jó áttekintés, de nézd meg Lodewijk alábbi válaszát a mélyebb részletekért.

1000 láb magasból nézve...

A TypeScript a JavaScript egy felső halmaza, amely elsősorban opcionális statikus típusként, osztályokat és interfészeket biztosít. Az egyik nagy előnye, hogy lehetővé teszi az IDE-k számára, hogy gazdagabb környezetet biztosítsanak a gyakori hibák írás közbeni felderítéséhez.

Ahhoz, hogy elképzelést kapj arról, mire gondolok, nézd meg a Microsoft nyelvről szóló bevezető videóját.

Egy nagy JavaScript-projekt esetében a TypeScript használata robusztusabb szoftverhez vezethet, miközben továbbra is telepíthető ott, ahol egy normál JavaScript-alkalmazás futna.

Ez nyílt forráskódú, de az intelligens Intellisense-t csak akkor kapod gépelés közben, ha egy támogatott IDE-t használsz. Kezdetben ez csak a Microsoft Visual Studio-ja volt (amit Miguel de Icaza blogbejegyzésében is megemlített). Manapság más IDE-k is kínálnak TypeScript-támogatást.

Vannak más ilyen technológiák?

Van CoffeeScript, de annak valójában más célja van. Véleményem szerint a CoffeeScript az emberek számára biztosít olvashatóságot, de a TypeScript a választható statikus típusellenőrzésén keresztül a eszközök számára is mély olvashatóságot nyújt (lásd ezt a friss blogbejegyzést egy kis kritika számára). Van Dart is, de az teljesen a JavaScript helyettesítése (bár JavaScript kódot is tud generálni).

Példa

Példaként itt van néhány TypeScript (ezzel játszhatsz a TypeScript Playground-ban)

class Greeter {
    greeting: string;
    constructor (message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

És íme a JavaScript, amit létrehozna

var Greeter = (function () {
    function Greeter(message) {
        this.greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + this.greeting;
    };
    return Greeter;
})();

Figyeld meg, hogyan határozza meg a TypeScript a tagváltozók és az osztály metódusparaméterei típusát. Ez a JavaScriptre való fordításkor eltűnik, de az IDE és a fordító használja a hibák felderítésére, például amikor numerikus típust adunk át a konstruktorhoz.

Az is képes arra, hogy kitalálja a típusokat, amelyek nincsenek kifejezetten deklarálva, például megállapítaná, hogy a greet() metódus egy karakterláncot ad vissza.

TypeScript hibakeresése

Sok böngésző és IDE közvetlen hibakeresési támogatást nyújt sourcemap-ek segítségével. További részletekért lásd ezt a Stack Overflow kérdést: TypeScript kód hibakeresése a Visual Studio-val.

Tudni szeretnél többet?

Eredetileg ezt a választ akkor írtam, amikor a TypeScript még friss volt. Nézd meg Lodewijk válaszát erre a kérdésre néhány frissebb részletért.

Válasz #2

A TypeScript kapcsolata a JavaScripttel

A TypeScript a JavaScript típusos fölénytelve, amely egyszerű JavaScriptre fordul - typescriptlang.org.

A JavaScript egy programozási nyelv, amelyet az ECMA Technikai Bizottsága 39 (TC39) fejleszt, amely egy olyan embercsoport, amely sok különböző érdekelt félből áll. A TC39 egy, az ECMA által szervezett bizottság: egy belső szabványügyi szervezet. A JavaScriptnek sok különböző megvalósítása van sok különböző szállító által (pl. Google, Microsoft, Oracle stb.). A JavaScript célja, hogy a web lingua franca-ja legyen.

A TypeScript a JavaScript nyelv egy szuperszettje, amelynek egyetlen nyílt forráskódú fordítója van, és főként egyetlen szállító, a Microsoft fejleszti. A TypeScript célja, hogy a típus-rendszer segítségével korán észlelje a hibákat, és hogy a JavaScript fejlesztést hatékonyabbá tegye.

Lényegében a TypeScript három módon éri el céljait:

Támogatás a modern JavaScript funkciókhoz - A JavaScript nyelv (nem a futtatási környezet) az ECMAScript szabványokon keresztül van szabványosítva. Nem minden böngésző és JavaScript futtatási környezet támogatja az összes funkciót az összes ECMAScript szabványból (lásd ezt az áttekintést). A TypeScript lehetővé teszi számos legújabb ECMAScript funkció használatát, és lefordítja azokat az Ön által választott régebbi ECMAScript célokra (lásd a --target fordítóopció alatti céllistát). Ez azt jelenti, hogy biztonságosan használhat új funkciókat, például modulokat, lambda függvényeket, osztályokat, spread operátort és destrukturálást, miközben visszafelé kompatibilis marad a régebbi böngészőkkel és JavaScript futtatási környezetekkel.
Fejlett típus-rendszer - A típus-támogatás nem része az ECMAScript szabványnak, és valószínűleg soha nem lesz az, a JavaScript fordított (interpreted) jellege miatt, nem pedig a fordított (compiled) jellege miatt. A TypeScript típus-rendszere hihetetlenül gazdag, és tartalmazza: interfészeket, enumerációkat (enumokat), hibrid típusokat, generikus típusokat, unió/interakció típusokat, hozzáférési módosítókat és még sok mást. A TypeScript hivatalos weboldala áttekintést ad ezekről a funkciókról. A TypeScript típus-rendszere vetekszik a legtöbb más típusos nyelvvel, és bizonyos esetekben vitathatóan még erősebb is.
Fejlesztői eszköztámogatás - A TypeScript fordítója háttérfolyamatként futhat, hogy támogassa a fokozatos fordítást és az IDE integrációt, így könnyebben navigálhatsz, azonosíthatod a problémákat, megvizsgálhatod a lehetőségeket és átalakíthatod a kódbázisodat.

A TypeScript kapcsolata más, JavaScript-re célozó nyelvekkel

A TypeScript egyedi filozófiával rendelkezik más, JavaScriptre fordító nyelvekhez képest. A JavaScript kód érvényes TypeScript kód; a TypeScript a JavaScript egy kiterjesztése. Gyakorlatilag átnevezheti a .js fájljait .ts fájlokra, és elkezdheti használni a TypeScriptet (lásd az alábbi „JavaScript interoperabilitás” részt). A TypeScript fájlokat olvasható JavaScriptre fordítják, így a visszafordítás lehetséges, és a fordított TypeScript megértése egyáltalán nem nehéz. A TypeScript a JavaScript sikereire épít, miközben javít annak gyengeségein.

Egyik oldalon ott vannak a jövőbiztos eszközök, amelyek a modern ECMAScript szabványokat régebbi JavaScript verziókra fordítják le, a legnépszerűbb közülük a Babel. Másik oldalon pedig ott vannak azok a nyelvek, amelyek teljesen eltérhetnek a JavaScripttől, de JavaScriptre céloznak, mint például a CoffeeScript, Clojure, Dart, Elm, Haxe, Scala.js és még sok más (ld. ezt a listát). Bár ezek a nyelvek lehetnek jobbak annál, amivé a JavaScript jövője válhat, nagyobb a kockázatuk, hogy nem találnak elég elfogadást ahhoz, hogy jövőjük garantált legyen. Az is előfordulhat, hogy nehezebben találni tapasztalt fejlesztőket ezekhez a nyelvekhez, bár akiket találunk, gyakran lelkesebbek lehetnek. A JavaScript-tel való együttműködés is kicsit bonyolultabb lehet, mivel távolabb állnak attól, ami a JavaScript valójában.

A TypeScript e két szélsőség között helyezkedik el, így kiegyensúlyozza a kockázatot. A TypeScript semmilyen mércével nem számít kockázatos választásnak. Nagyon kevés erőfeszítést igényel a megszokása, ha ismered a JavaScriptet, mivel nem teljesen különböző nyelv, kiváló JavaScript-interop támogatással rendelkezik, és az utóbbi időben nagy elfogadottságnak örvend.

Opcionálisan statikus típusként való típus és típuskövetkeztetés

A JavaScript dinamikusan típusos. Ez azt jelenti, hogy a JavaScript nem tudja, hogy egy változó milyen típusú, amíg az ténylegesen nem jön létre futásidőben. Ez azt is jelenti, hogy lehet, hogy már túl késő. A TypeScript típus támogatást ad a JavaScripthez, és a típushibákat a JavaScriptre történő fordítás során elkapja. Az olyan hibák, amelyeket egy változó bizonyos típusúnak téves feltételezése okoz, teljesen megszüntethetők, ha jól játszol a kártyáiddal (hogy mennyire szigorúan tipizálod a kódodat, vagy egyáltalán tipizálod-e, az rajtad múlik).

A TypeScript egy kicsit könnyebbé teszi a típusok kezelését, és sokkal kevésbé explicit módon használja a típus-inferenciát. Például: var x="hello" a TypeScriptben ugyanaz, mint var x : string="hello". A típus egyszerűen a használatából következik. Még ha nem is adod meg kifejezetten a típusokat, azok akkor is jelen vannak, hogy megóvjanak attól, hogy valami olyat csinálj, ami egyébként futásidejű hibát eredményezne.

A TypeScript alapértelmezés szerint opcionálisan típusos. Például a function divideByTwo(x) { return x/2 } érvényes függvény TypeScriptben, amelyet bármilyen típusú paraméterrel lehet meghívni, bár nyilvánvalóan, ha stringgel hívjuk meg, az futásidejű hibát fog eredményezni. Pont úgy, ahogyan JavaScriptben is megszokhattad. Ez úgy működik, hogy ha nem lett kifejezetten típus hozzárendelve, és a típust nem lehetett kikövetkeztetni, ahogy a divideByTwo példában, a TypeScript implicitly a any típust rendeli. Ez azt jelenti, hogy a divideByTwo függvény típusjelzése automatikusan function divideByTwo(x : any) : any lesz. Van egy fordítókapcsoló, amely megakadályozza ezt a viselkedést: --noImplicitAny. Ennek a kapcsolónak az engedélyezése nagyobb biztonsági szintet ad, de azt is jelenti, hogy többet kell majd gépelni.

A típusoknak van költsége. Először is van egy tanulási görbe, másodszor pedig, természetesen, egy kicsit több időbe telik egy kódalap létrehozása a megfelelő, szigorú típusosság használatával. Tapasztalatom szerint ezek a költségek teljes mértékben megérik bármely komoly kódalap esetében, amelyet másokkal osztunk meg. Egy Nagy Méretű Tanulmány a Programozási Nyelvekről és a Kódminőségről a GitHub-on azt sugallja, hogy „a statikusan típusos nyelvek általában kevésbé hajlamosak hibára, mint a dinamikus típusok, és a szigorú típusosság jobb a gyenge típusosságnál ugyanebben a tekintetben”.

Érdekes megjegyezni, hogy ugyanaz a tanulmány azt találja, hogy a TypeScript kevésbé hajlamos a hibákra, mint a JavaScript:

Azoknál, akiknél pozitív együtthatók vannak, azt várhatjuk, hogy a nyelv, minden más tényezőt változatlannak feltételezve, több hibajavítással kapcsolatos commitot eredményez. Ezek a nyelvek közé tartozik a C, C++, JavaScript, Objective-C, Php és Python. A Clojure, Haskell, Ruby, Scala és TypeScript nyelvek mind negatív együtthatóval rendelkeznek, ami azt jelzi, hogy ezek a nyelvek az átlagosnál kevésbé valószínű, hogy hibajavító commitokat eredményeznek.

Fejlesztett IDE-támogatás

A TypeScript fejlesztési élménye nagyszerű előrelépés a JavaScript-hez képest. Az IDE a TypeScript fordítója által valós időben kap információt a gazdag típusinformációról. Ez néhány nagy előnnyel jár. Például a TypeScript segítségével biztonságosan végezhetők átnevezéses refaktorálások az egész kódbázison. A kód-kiegészítés segítségével inline segítséget kaphatunk bármelyik könyvtár által kínált függvényekről. Már nem kell őket megjegyezni vagy online referenciákban keresgélni. A fordítási hibákat közvetlenül az IDE-ben, piros hullámos vonallal jelzi, miközben éppen kódolunk. Összességében ez jelentős termelékenységnövekedést tesz lehetővé a JavaScript-tel való munkához képest. Több időt lehet a kódolással tölteni és kevesebbet a hibakereséssel.

Széles körű IDE-k állnak rendelkezésre, amelyek kiváló támogatást nyújtanak a TypeScripthez, például a Visual Studio Code, a WebStorm, az Atom és a Sublime.

Szigorú null érték ellenőrzések

A futásidejű hibák, mint például a cannot read property 'x' of undefined vagy a undefined is not a function, rendkívül gyakran a JavaScript kódban előforduló hibák miatt következnek be. A TypeScript alapértelmezés szerint már csökkenti az ilyen hibák előfordulásának valószínűségét, mivel nem lehet olyan változót használni, amelyet a TypeScript fordító nem ismer (a any típusú változók tulajdonságai kivételével). Ugyanakkor még mindig lehetséges hibásan használni egy olyan változót, amely undefined-re van állítva. Azonban a TypeScript 2.0 verziójával teljesen el lehet kerülni az ilyen hibákat nem-nullábilis típusok használatával. Ez a következőképpen működik:

A szigorú null-ellenőrzések engedélyezése esetén (--strictNullChecks fordítókapcsoló) a TypeScript fordító nem engedi, hogy undefined értéket rendeljünk egy változóhoz, hacsak kifejezetten nem deklaráljuk, hogy nullable típussal rendelkezik. Például a let x : number=undefined fordítási hibát fog eredményezni. Ez tökéletesen illeszkedik a típelmélethez, mivel a undefined nem szám. Ezt javíthatjuk úgy, hogy x értékét a number és undefined összeg típusaként definiáljuk: let x : number | undefined=undefined.

Ha egy típust nullable-ként ismerünk, ami azt jelenti, hogy olyan típusú, ami null vagy undefined értéket is felvehet, a TypeScript fordító képes a vezérlési áramlás alapú típus-elemzés révén meghatározni, hogy a kód biztonságosan használhat-e egy változót, vagy sem. Más szóval, amikor ellenőrzöd, hogy egy változó undefined-e például egy if utasítással, a TypeScript fordító kikövetkezteti, hogy az adott kódvezérlési ágban a típus már nem nullable, és ezért biztonságosan használható. Íme egy egyszerű példa:

let x: number | undefined;
if (x !== undefined) x += 1; // this line will compile, because x is checked.
x += 1; // this line will fail compilation, because x might be undefined.

A build során Anders Hejlsberg, a TypeScript 2016-os konferenciai társtervezője részletes magyarázatot és bemutatót tartott erről a funkcióról: videó (44:30-tól 56:30-ig).

Összeállítás

A TypeScript használatához szükséged van egy build folyamatra, hogy lefordítsd a JavaScript kódra. A build folyamat általában csak néhány másodpercet vesz igénybe, természetesen a projekt méretétől függően. A TypeScript fordító támogatja a fokozatos fordítást (--watch fordító jelző), így minden további módosítás gyorsabban fordítható le.

A TypeScript fordító beágyazhatja a forrástérkép-információkat a generált .js fájlokba, vagy létrehozhat külön .map fájlokat. A forrástérkép-információkat hibakereső eszközök, például a Chrome DevTools és más IDE-k használhatják, hogy a JavaScript sorait a TypeScript-ben őket előállító sorokhoz kapcsolják. Ez lehetővé teszi, hogy közvetlenül a TypeScript kódon állíts be töréspontokat és vizsgáld a változókat futásidőben. A forrástérkép-információk meglehetősen jól működnek, jóval a TypeScript előtt is léteztek, de a TypeScript hibakeresése általában nem olyan jó, mint közvetlenül a JavaScript használata esetén. Vegyük például a this kulcsszót. Az ES2015 óta a this kulcsszó lezárások körüli megváltozott szemantikája miatt a this valójában létezhet futásidőben egy _this nevű változóként (lásd ezt a választ). Ez összezavarhat debugolás közben, de általában nem jelent problémát, ha tudsz róla, vagy megvizsgálod a JavaScript kódot. Meg kell jegyezni, hogy a Babel ugyanilyen típusú problémával küzd.

Van néhány más trükk is, amit a TypeScript fordító tud, például dekorátorok alapján elfogó kód generálása, modul betöltő kód generálása különböző modulrendszerekhez és JSX elemzése. Azonban valószínűleg szükséged lesz egy építőeszközre a TypeScript fordítón kívül. Például, ha tömöríteni szeretnéd a kódodat, más eszközöket kell hozzáadnod az építési folyamatodhoz, hogy ezt meg tudd tenni.

Elérhetők TypeScript fordítási bővítmények a Webpack, Gulp, Grunt és gyakorlatilag bármely más JavaScript építőeszközhöz. A TypeScript dokumentációjához tartozik egy szakasz az építőeszközökkel való integrációról, amely mindet lefedi. Ezenkívül elérhető egy linter is, ha még több fordítási idejű ellenőrzést szeretnél. Emellett rengeteg induló projekt található, amelyek segítenek a TypeScript gyors használatának elkezdésében más technológiákkal kombinálva, mint például Angular 2, React, Ember, SystemJS, Webpack, Gulp stb.

JavaScript interoperabilitás

Mivel a TypeScript nagyon szorosan kapcsolódik a JavaScripthez, kiváló interoperabilitási képességekkel rendelkezik, de a JavaScript könyvtárakhoz a TypeScript-ben további munkára van szükség. TypeScript definíciókra van szükség, hogy a TypeScript fordító megértse, hogy a _.groupBy, angular.copy vagy $.fadeOut függvényhívások valójában nem illegális utasítások. Ezeknek a függvényeknek a definíciói .d.ts fájlokban találhatók.

A definíció legegyszerűbb formája az lehet, ha lehetővé teszi, hogy egy azonosítót bármilyen módon használjanak. Például a Lodash használatakor egyetlen soros definíciós fájl declare var _ : any lehetővé teszi, hogy bármilyen függvényt meghívj az _-n, de természetesen így még mindig hibákat is elkövethetsz: _.foobar() egy jogos TypeScript hívás lenne, de természetesen futásidőben illegális hívás. Ha megfelelő típus támogatást és kódkiegészítést szeretnél, a definíciós fájlodnak pontosabbnak kell lennie (lásd a Lodash definíciókat példaként).

Az npm modulok, amelyek előre csomagolt saját típusdefiníciókkal rendelkeznek, automatikusan értelmezhetők a TypeScript fordítóprogramja által (lásd a dokumentációt). Gyakorlatilag bármely más, fél-népszerű JavaScript könyvtárhoz, amely nem tartalmaz saját definíciókat, valaki már készített típusdefiníciókat egy másik npm modulon keresztül. Ezek a modulok "@types/" előtaggal rendelkeznek, és a DefinitelyTyped nevű GitHub adattárból származnak.

Van egy figyelmeztetés: a típusdefinícióknak meg kell egyezniük a könyvtárnak azzal a verziójával, amit futási időben használsz. Ha nem egyeznek, a TypeScript letilthatja, hogy egy létező függvényt hívj meg, vagy egy létező változót dereferálj, vagy engedheti, hogy egy nem létező függvényt hívj meg, vagy egy nem létező változót dereferálj, csupán azért, mert a típusok a fordítási időben nem egyeznek a futási idővel. Tehát győződj meg róla, hogy a megfelelő verziójú típusdefiníciókat töltöd be a használt könyvtár megfelelő verziójához.

Őszintén szólva, ennek van egy kis bonyodalma, és ez lehet az egyik oka annak, hogy nem a TypeScriptet választod, hanem valami olyat, mint a Babel, amely egyáltalán nem szenved attól, hogy típusrétegeket kell beszerezned. Másrészt, ha tudod, mit csinálsz, könnyen legyőzheted az összes olyan problémát, amelyet a helytelen vagy hiányzó definíciós fájlok okoznak.

Átváltás JavaScriptről TypeScriptre

Bármely .js fájl átnevezhető .ts fájlra, és a TypeScript fordítón keresztül futtatható, hogy szintaktikailag ugyanazt a JavaScript kódot kapjuk kimenetként (ha az eredetileg szintaktikailag helyes volt). Még akkor is, ha a TypeScript fordító fordítási hibákat talál, akkor is létrehoz egy .js fájlt. Emellett .js fájlokat is elfogad bemenetként a --allowJs kapcsolóval. Ez lehetővé teszi, hogy rögtön TypeScripttel kezdjünk. Sajnos, a fordítási hibák valószínűleg az elején elő fognak fordulni. Emlékezni kell arra, hogy ezek nem olyan kritikus hibák, mint amilyenekhez más fordítók esetében hozzászoktunk.

Azok a fordítási hibák, amelyeket az elején kapunk, amikor egy JavaScript-projektet TypeScript-projektté alakítunk, TypeScript természetéből adódóan elkerülhetetlenek. A TypeScript minden kódot ellenőriz érvényesség szempontjából, és ezért tudnia kell minden használt függvényről és változóról. Ezért mindenhez szükség van típusdefiníciókra, különben fordítási hibák fognak fellépni. Ahogy a fenti fejezetben említettük, gyakorlatilag bármely JavaScript-keretrendszerhez léteznek .d.ts fájlok, amelyeket könnyen be lehet szerezni a DefinitelyTyped csomagok telepítésével. Előfordulhat azonban, hogy valamilyen ritka könyvtárat használtál, amelyhez nem áll rendelkezésre TypeScript-definíció, vagy hogy néhány JavaScript-primitívet polyfill-eltél. Ebben az esetben meg kell adnod a típusdefiníciókat ezekhez a részekhez, hogy a fordítási hibák eltűnjenek. Egyszerűen hozz létre egy .d.ts fájlt, és add hozzá a tsconfig.json files tömbjéhez, így a TypeScript fordító mindig figyelembe veszi. Ebben a fájlban azokat a részeket, amikről a TypeScript nem tud, deklaráld any típusúként. Miután minden hibát megszüntettél, fokozatosan bevezetheted a típusokat ezekbe a részekbe az igényeid szerint.

A build folyamatod (újrabe)konfigurálására is szükség lesz ahhoz, hogy a TypeScript bekerüljön a build folyamatba. Ahogy a fordításról szóló fejezetben említettük, rengeteg jó forrás áll rendelkezésre, és biztatlak, hogy keress vetőprojektek, amelyek azokat az eszközök kombinációját használják, amivel szeretnél dolgozni.

A legnagyobb akadály a tanulási görbe. Azt javaslom, hogy először játssz egy kisebb projekttel. Nézd meg, hogyan működik, hogyan épül fel, mely fájlokat használja, hogyan van konfigurálva, hogyan működik az IDE-dben, hogyan van felépítve, mely eszközöket használ, stb. Egy nagy JavaScript kódállomány TypeScript-re való átalakítása megvalósítható, ha tudod, mit csinálsz. Olvasd el például ezt a blogot a 600 ezer sor TypeScript-re való átalakításáról 72 óra alatt. Csak győződj meg róla, hogy jól kiismered a nyelvet, mielőtt belevágsz.

Örökbefogadás

A TypeScript nyílt forráskódú (Apache 2 licenc alatt, lásd GitHub) és a Microsoft támogatja. Anders Hejlsberg, a C# vezető építésze vezeti a projektet. Ez egy nagyon aktív projekt; a TypeScript csapata az elmúlt években sok új funkciót adott ki, és még sok nagyszerű funkció van tervben (lásd a ütemtervet).

Néhány tény az örökbefogadásról és a népszerűségről:

A 2017-es StackOverflow fejlesztői felmérésben a TypeScript volt a legnépszerűbb JavaScript transzpilátor (összesítésben a 9. helyen), és a legkedveltebb programozási nyelvek kategóriájában a harmadik helyezést érte el.
A 2018-as State of JS felmérésben a TypeScript-et a JavaScript változatok kategóriájában az egyik két nagy nyertesnek kiáltották ki (az ES6-tal együtt, ami a másik).
A 2019-es StackOverflow fejlesztői felmérésben a TypeScript a 9. helyre emelkedett a legnépszerűbb nyelvek között a profi fejlesztők körében, maga mögé utasítva a C és C++ nyelveket is. Ismét a harmadik helyet szerezte meg a legkedveltebb nyelvek között.
A 2020-as StackOverflow fejlesztői felmérésében a TypeScript volt a második legkedveltebb technológia.

Válasz #3

A TypeScript hasonló dolgot csinál, mint amit a less vagy a sass tesz a CSS-hez. Ezek a CSS fölé épülő bővítmények, ami azt jelenti, hogy minden JS kód, amit írsz, érvényes TypeScript kód. Ráadásul használhatod azokat a további finomságokat, amiket hozzáad a nyelvhez, és az átalakított kód érvényes js lesz. Még azt is beállíthatod, hogy a JS melyik verziójára szeretnéd az eredményül kapott kódot.

Jelenleg a TypeScript az ES2015 fölérendeltje, így jó választás lehet az új JavaScript funkciók elsajátításának elkezdéséhez és azok a projektedhez szükséges szabványra való transzpilálásához.

Válasz #4

"TypeScript Alapok" -- egy Pluralsight videókurzus Dan Wahlin és John Papa előadásában, ami tényleg jó, jelenleg (2016. március 25.) frissítve a TypeScript 1.8-nak megfelelően, bevezetés a TypeScriptbe.

Számomra az igazán jó tulajdonságok, a kellemes intellisense lehetőségek mellett, a osztályok, interfészek, modulok, az AMD megvalósításának egyszerűsége, és a lehetőség, hogy a Visual Studio Typescript hibakeresőt használjam IE-vel indítva.

Összefoglalva: Ha a rendeltetésszerűen használják, a Typescript megbízhatóbbá és könnyebbé teheti a JavaScript programozást. Jelentősen növelheti a JavaScript programozó termelékenységét a teljes SDLC során.

Válasz #5

Az Ecma script 5 (ES5), amelyet minden böngésző támogat és előre le van fordítva. Az ES6/ES2015 és az ES/2016 idén jelent meg sok változással, így ezeknek a változásoknak a megjelenítésére van valami köztes, amiről gondoskodnia kell, tehát a TypeScript.

• A TypeScript típusok -> Ez azt jelenti, hogy meg kell határoznunk minden tulajdonság és metódus adattípusát. Ha ismered a C#-ot, a TypeScript könnyen érthető.

• A TypeScript nagy előnye, hogy a típushoz kapcsolódó problémákat már korán, a produkcióba kerülés előtt azonosítani tudjuk. Ez lehetővé teszi, hogy az egységtesztek meghiúsuljanak, ha bármilyen típuseltérés van.