Deklaracja typu w TypeScript

Question

Czy TypeScript jest wrażliwy na kolejność deklaracji typu?

Zmiana kolejności typu powoduje błąd wewnątrz Kątowymi 2 (beta.0), który (AFAIK) jest realizowany przy użyciu samej (to dlaczego ten błąd wydaje się takie dziwne & znaczenia dla mnie) maszynopis:

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

Załóżmy, że mamy plik t1.ts:

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

Uruchamiając aplikację widzimy wspomniany błąd na stronie klienta. Ale jeśli odwrócimy kolejność deklaracji w tym pliku, błąd zniknie (tylko dla zapisu, obecnie posuwam się naprzód, mając to na uwadze, & to działa).

Aby odtworzyć ten błąd, musimy jeszcze pięć plików:

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, []); 

I index.html który jest nieco większy, ale zasadniczo ma strukturę index.html z samouczka na angular internetowej.

Answer 1

Sam typScript nie jest wrażliwy, ale został skompilowany do JS.

class A extends B {} 
class B {} 

W JS:

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

B jest zdefiniowana w linii 1.

Answer 2

Mam lanego mój głos na odpowiedź vasa_c jak to jest prawidłowa. Poniżej chciałbym podać więcej informacji na ten temat, aby ułatwić PO zrozumienie problemu.

Jeśli weźmiemy swój przykładowy kod:

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

i skompilować go - to co końcowy wynik będzie podobny:

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; 

nocie, że otrzymany kod jest nie tylko funkcjonować definicje . To są funkcje i zmienne. To robi różnicę. Ponieważ masz zarówno deklaracje, jak i wyrażenia. Więcej na ten temat i dlaczego z wyrażeniami w js kolejność ma znaczenie, można przeczytać w tym doskonałym poście: JavaScript function declaration and evaluation order