compilare - Care este avantajul utilizării atât a TypeScript, cât și a Traceur?

Poți configura TypeScript pentru a genera fie ES5, fie ES6. Atâta timp cât dorești să rulezi aplicația ta pe o platformă care nu suportă nativ ES6, trebuie să compilezi ES6 în ES5 folosind un compilator precum Traceur (și să incluzi biblioteca de rulare Traceur).

Există vreun avantaj în a face acest lucru în loc să îi spui pur și simplu TypeScript să genereze ES5? (Nu mă aștept ca aplicația să vizeze vreodată doar platforme native ES6)

Din câte am înțeles, nu poți scrie un program în TypeScript (1.5) care să nu poată rula pe ES5 (atâta timp cât programul se compilează și incluzi bibliotecile corecte). Mă înșel?

Răspuns #1

Motive pentru a folosi Babel sau Traceur în loc de TypeScript

Până acum, echipa TypeScript a ales să nu facă codul generat dependent de un runtime. Unele caracteristici ale ES6 pot fi utilizate cu ușurință în TS prin polyfill-uri (exemplu: Promises din ES6). Alte caracteristici necesită cooperarea transpilerului și a unui polyfill (exemplu: generatoarele din ES6). Utilizarea unui generator cu TS este posibilă (începând cu TS 1.6), dar ținta trebuie să fie ES6. Aceasta este un motiv bun pentru a folosi Babel sau Traceur.

Motive pentru a nu folosi Babel sau Traceur în loc de TypeScript

Dar există și alte motive bune pentru a nu folosi Babel și Traceur. Doar încearcă să transpilezi niște cod ES6.

Codul ES6:

let list = ['ab', 'cd'];
for (let item of list) {
    console.log(item);
}

ES5 produs de TypeScript (folosind Playground-ul):

var list = ['ab', 'cd'];
for (var _i = 0; _i < list.length; _i++) {
      var item = list[_i];
      console.log(item);
}

ES5 produs de Traceur (utilizând REPL-ul):

$traceurRuntime.ModuleStore.getAnonymousModule(function() {
    "use strict";
    var list = ['ab', 'cd'];
    var $__4 = true;
    var $__5 = false;
    var $__6 = undefined;
    try {
      for (var $__2 = void 0,
          $__1 = (list)[$traceurRuntime.toProperty(Symbol.iterator)](); !($__4 = ($__2 = $__1.next()).done); $__4 = true) {
        var item = $__2.value;
        {
          console.log(item);
        }
      }
    } catch ($__7) {
      $__5 = true;
      $__6 = $__7;
    } finally {
      try {
        if (!$__4 && $__1.return != null) {
          $__1.return();
        }
      } finally {
        if ($__5) {
          throw $__6;
        }
      }
    }
    return {};
});
//# sourceURL=traceured.js

ES5 produs de Babel (folosind REPL-ul):

'use strict';

var list = ['ab', 'cd'];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;

try {
    for (var _iterator = list[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var item = _step.value;

        console.log(item);
    }
} catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
} finally {
    try {
        if (!_iteratorNormalCompletion && _iterator['return']) {
            _iterator['return']();
        }
    } finally {
        if (_didIteratorError) {
            throw _iteratorError;
        }
    }
}

Soluțiile de la Traceur și Babel sunt urâte, deoarece variabila list ar putea fi un iterable ES6 și aceste transpiler-e nu sunt conștiente de tipuri. TypeScript deduce că tipul variabilei list este un array string[] și produce numai codul pentru array.