Visual Studio Code und eigene TypeScript Definition Files

Vor kurzem bin ich über Visual Studio Code gestolpert und bin angenehm überrascht. Ich hätte nicht gedacht, dass Microsoft es wirklich schafft, die Annehmlichkeiten einer großen IDE in einen leichtgewichtigen Editor zu verpacken.

Nun habe ich begonnen VSCode auch im Alltag einzusetzen. Ich bin damit deutlich schneller unterwegs als mit Brackets. In den letzten Tagen habe ich meine Vertretungsplan-Webapp erweitert und wollte jetzt für meine Vertretungsplan-Bibliothek, die ich geschrieben habe, TypeScript Definition Files anlegen. Mit denen kann VSCode die IntelliSense-Dienste anbieten.

Nach einigem hin und her und ganz viel Gesuche habe ich endlich die Lösung des Rätsels gefunden. Und ich musste einen Fehler akzeptieren.
Das alte Resultat ist folgendes:

interface VP {
    new (webViewElementID: string): VP;
    prototype: VP;
     
    username: string;
    password: string;
    webView: string;
    classID: number;
    CW: number;
    genericPlanStart: string;
    genericTeacherPlanStart: string;
    classList: string[];
    teacherList: string[];
    roomList: string[];
    teacherMode: boolean;
     
    setType(type: string): void;
    navigate(): void;
    getCurrentCW(): number;
    retrieveClassList(): void;
    parseRawData(newRawData: string): void;
    parseTeacherRawData(newRawData: string): void;
    getClassList(listType: string): string[];
    setClassID(id: number): void;
    parseClassID(): string;
}
 
declare var Vertretungsplan: VP;
 
declare var classFavList: string[];
declare var classList: string[];
declare var isFaved: boolean; 
declare var isAlreadyFav: boolean;
declare var classID: number;
 
declare function refreshFavListSelector(): void;

Hier die d.ts-Datei für lose Typen-Definitionen:

declare var classFavList: string[];
declare var classList: string[];
declare var isFaved: boolean; 
declare var isAlreadyFav: boolean;
declare var classID: number;

declare function refreshFavListSelector(): void;
declare function getWeekNumber(): number;
declare class VertretungsplanTP {
    webView: string;
    classID: number;
    CW: number;
    currentType: string;
    genericPlanStart: string;
    genericTeacherPlanStart: string;
    bigPlanEnding: string;
    classList: string[];
    teacherList: string[];
    roomList: string[];
    teacherMode: boolean;
    username: string;
    password: string;
    constructor(webViewElementID: string);
    setType(type: string): void;
    navigate(): void;
    getCurrentCW(): number;
    retrieveClassList(): void;
    parseRawData(newRawData: any): void;
    parseTeacherRawData(newRawData: string): void;
    getClassList(listType: string): void;
    setClassID(id: number): void;
    parseClassID(): string;
}

Mit dieser Datei bot mir VSCode endlich IntelliSense-Dienste für meine Bibliothek an. Wenn man seine Bibliothek nicht gerade selber mit TypeScript schreibt und danach kompilieren lässt, dann ist das hier eine nützliche Methode, um IntelliSense-Unterstützung für eigene JS-Dateien zu bekommen.

Eventuell werde ich die Klasse in TypeScript neu implementieren, das ist aber grundsätzlich nicht nötig.


Nachtrag: Ich habe nun die Klasse in TypeScript neu implementiert und habe die Definitionen nun in zwei d.ts-Dateien aufgeteilt. Eine Definition beinhaltet lose Funktionen und Variablen innerhalb der App und die andere wird mit tsc generiert und beinhaltet die Deklarationen und Typen-Definitionen der Vetretungsplan-Klasse.

Physik – Der Fotoeffekt (Hausaufgabe)

Ich habe heute eine Physik-Hausaufgabe bearbeitet, die ich ganz spannend finde, und deswegen mit der Öffentlichkeit teile.

geg: λ = 500nm ∨ vmax 6⋅105 ms-1 ∨ mE = 9,109⋅10-31kg
ges: Ea, fgrenz

c = λ⋅f ⇔ f = c⋅λ-1 ⇒ f = c ⋅(500nm)-1 = 599,6⋅109Hz

Ekin = 0,5⋅m⋅v2 = 0,5 ⋅ 9,109⋅10-31kg ⋅ (599,6⋅109ms-1)2 = 163,962⋅10-21J

Ekin(f) = Ephot-Ea
⇔ Ea = Ephot-Ekin
⇔ Ea = h⋅f – 0.5 ⋅ mE ⋅ v2
⇔ Ea = h⋅c⋅λ-1 – 0.5 ⋅ mE ⋅ v2
⇔ Ea ≈ 233,33⋅10-21J

Ephot – Ea = 0
⇔ Ephot = Ea
⇔ h⋅f = Ea
⇔ f = Ea ⋅ h-1
⇔ f ≈ 352,148⋅1012Hz


Hier wird von maximaler Geschwindigkeit gesprochen, da die Elektronen effektiv nur eine bestimmte kinetische Energie maximal vom Photon erhalten, nämlich dich Energie des Photons (Ephot=h⋅f) abzüglich der Ablösenergie (Ea = h⋅fgrenz). Damit ein Elektron mit einer schnelleren Geschwindigkeit herausgelöst werden soll, muss das Licht zwangsläufig eine geringere Wellenlänge (c = λ ⋅ f) besitzen.

Netzwerkprotokoll programmieren #1

Im Schulunterricht haben wir die Aufgabe bekommen, ein Netzwerkprotokoll zu entwerfen, welches nur mit einer Datenleitung einer Bezugsleitung auskommt. Dafür habe ich bereits einige wenige Codezeilen Proof of Concept geschrieben und festgestellt, dass die Datenpakete, die unser Busprotokoll übermitteln soll, entschieden zu groß sind, um vom µC und vom PC noch als Zahl darstellbar zu sein.
Folglich werden die Datenpaketen in Strings gespeichert, und zum Übertragen in handlichere Zahlenpakete aufgeteilt, die mit bitweisen Operationen verschickt werden können.

Das Proof-of-Concept-Programm habe ich mit C# geschrieben, welches der Syntax von C noch am ähnlichsten ist. Jedoch werde ich auf einem µC nicht auf alle Konvertierungsfunktionen zurückgreifen können, die C# bietet. Wie genau das gelöst wird, muss noch genauer ermittelt werden.

Ein Auszug aus meinem Programm:


static long BuildPackage(int src, int dst, int packageType, string data)
{
    long returnValue = 1;
    returnValue = returnValue << 4;
    returnValue += dst;
    returnValue = returnValue << 4;
    returnValue += src;
    returnValue = returnValue << 4;
    returnValue += packageType;

    for ( int i = 0; i < data.Length; i++)
    {
        string returnString = Convert.ToString(returnValue, 2);
        char character = Convert.ToChar(data[i]);
        returnString += Convert.ToString(character, 2).PadLeft(8, '0');
        Console.WriteLine(returnString);

        returnValue = Convert.ToInt64(returnString);
    }

    returnValue = returnValue << 4;
    returnValue += 0x5; // EOT
    returnValue = returnValue << 4;
    returnValue += 0x4;

    return returnValue;
}

Dieser Code wird ziemlich bald eine OverflowException in Zeile 18 werfen.