Type Declaration Order in TypeScript

Question

TypeScript è sensibile all'ordine delle dichiarazioni di tipo?

Cambiare l'ordine di tipo causa un errore interno angolare 2 (beta.0), che (per quanto ne so) è implementata utilizzando dattiloscritto in sé (che è il motivo per cui questo errore sembra così strano & irrilevante per me):

angular2-polyfills.js:138 Error: Cannot read property 'prototype' of undefined(…)

Supponiamo di avere un file t1.ts:

export class AuthResponse extends JsonResponse { } 
export class JsonResponse { 
    public code: ResultCode; 
} 
export enum ResultCode { } 

Quando si avvia l'applicazione, si vede l'errore riportato, al lato client. Ma se invertiamo l'ordine delle dichiarazioni in questo file, l'errore scompare (per la cronaca, al momento sto andando avanti, tenendo presente questo & funziona).

Per riprodurre questo errore abbiamo bisogno di più di cinque file:

t2.ts:

import {AuthResponse, JsonResponse, ResultCode} from './t1'; // this order? 

export class DummyAction { 
    doSomething() { 
     console.log('test, starting ...'); 

     var v = new AuthResponse(); 
     return v; 
    } 
} 

app.component.ts:

import {Component, OnInit} from 'angular2/core'; 
import {DummyAction} from './components/t2';    

@Component({  
    selector: 'root-app', 
    templateUrl: '/app/templates/app.html', 
}) 
export class AppComponent implements OnInit { 
    constructor() { 
     var tester = new DummyAction(); 
     // tester.runTest(); 
    } 

    ngOnInit() { } 
} 

app.html:

<h1>TEST</h1> 

boot.ts:

import {bootstrap} from 'angular2/platform/browser'; 
import {AppComponent} from './app.component'; 

bootstrap(AppComponent, []); 

E index.html che è un po 'più grande, ma in sostanza, ha la struttura di index.html da tutorial su angular sito.

Answer 1

TypeScript non sensibile, ma compilato per JS.

class A extends B {} 
class B {} 

In JS:

var A = (function (_super) { /* ... */ })(B); 
var B = (function() { /* ... */ })(); 

B non è definito sulla linea 1.

Answer 2

ho fuso il mio voto per la risposta vasa_c in quanto è quella corretta. Di seguito vorrei fornire ulteriori informazioni su tale questione, per cui sarà più facile per l'OP comprendere il problema.

Se vi toglierà il codice di esempio:

export class AuthResponse extends JsonResponse { } 
export class JsonResponse { 
    public code: ResultCode; 
} 
export enum ResultCode { } 

e compilarlo - questo è ciò che il risultato finale sarà come:

var AuthResponse = (function (_super) { 
    __extends(AuthResponse, _super); 
    function AuthResponse() { 
     _super.apply(this, arguments); 
    } 
    return AuthResponse; 
})(JsonResponse); 
exports.AuthResponse = AuthResponse; 
var JsonResponse = (function() { 
    function JsonResponse() { 
    } 
    return JsonResponse; 
})(); 
exports.JsonResponse = JsonResponse; 
(function (ResultCode) { 
})(exports.ResultCode || (exports.ResultCode = {})); 
var ResultCode = exports.ResultCode; 

Si noti che il codice risultante è non solo funzionare definizioni . Sono funzioni e variabili. Questo fa la differenza. Perché hai sia dichiarazioni che espressioni. Maggiori informazioni su questo argomento e sul perché con espressioni in js è importante leggere questo eccellente post: JavaScript function declaration and evaluation order