Haxe

Haxe

Paradigma	Multi-Paradigma
Entwickler	Haxe Foundation
Erstmals erschienen	14. November 2005; Vor 16 Jahren
Stabile Version	4.2.5[1]  / 6. März 2022; vor 4 Monaten
Disziplin tippen	Statisch, dynamisch über Anmerkungen, nominal
Implementierungssprache	Ocaml
Plattform	IA-32, x86-64, Aarch64, Waffenstillstand, Armhf, MIPS, mips64el, Mipsel, ppc64el, S390X
OS	Android, iOS; Linux, Mac OS, Fenster
Lizenz	Gpl 2.0, Bibliothek: MIT
Dateiname -Erweiterungen	.hx, .hxml
Webseite	haxe.org
Beeinflusst von
ECMaskript, Ocaml, Java, JavaScript, C ++, Php, C#, Python, Lua, Aktionen, Nekovm

Haxe ist eine Open Source^[2] hohes Level plattformübergreifend Programmiersprache und Compiler Dies kann für viele verschiedene Anwendungen und Quellcode erstellen Computerplattformen Aus einer Code-Basis. es ist Kostenlose und Open-Source-Software, freigelassen unter dem MIT -Lizenz. Der Compiler, geschrieben in Ocaml, wird unter dem freigelassen GNU Allgemeine öffentliche Lizenz (GPL) Version 2.

Haxe enthält eine Reihe von Funktionen und eine Standardbibliothek^[3] unterstützt über alle Plattformen hinweg, wie Numerische Datentypen, Saiten, Arrays, Karten, binär, Betrachtung, Mathematik, Http, Dateisystem und gemeinsam Dateiformate. Haxe enthält auch plattformspezifische APIs für jedes Compiler-Ziel.^[4] Kha, Openfl und Heaps.io sind beliebte Haxe-Frameworks, mit denen Multi-Plattform-Inhalte von einer Codebasis erstellt werden können.^[5]

Haxe entstand^[6] mit der Idee der Unterstützung Client-Seite und Server-Seite Programmierung in einer Sprache und Vereinfachung der Kommunikationslogik zwischen ihnen. Code, der in der Haxe -Sprache geschrieben wurde, kann sein zusammengestellt hinein JavaScript, C ++, Java, JVM, Php, C#, Python, Lua^[7] und Node.js.^[8] Haxe kann auch direkt kompilieren SWF, Hashlink und Nekovm Bytecode und läuft auch im interpretierten Modus.^[9]

Haxe unterstützt Externs (Definitionsdateien), die Typinformationen vorhandener Bibliotheken enthalten können, um die zielspezifische Interaktion auf Typ-Sicherheit zu beschreiben, wie C ++ Header -Dateien kann die Struktur der vorhandenen beschreiben Objektdateien. Dies ermöglicht es, die in den Dateien definierten Werte zu verwenden, als würden sie statisch eingegebene Haxe -Entitäten wären. Neben Externs gibt es andere Lösungen, um auf die nativen Funktionen jeder Plattform zuzugreifen.

Viele beliebt Ides und Quellcode -Redakteure haben Unterstützung für die HAXE -Entwicklung verfügbar.^[10] Keine bestimmte Entwicklungsumgebung oder ein Werkzeugsatz wird von der Haxe Foundation offiziell empfohlen, obwohl jedoch Vs Code, Intellij Idee Und Haxedevelop unterstützt die meisten Unterstützung für die Haxe -Entwicklung. Die Kernfunktionalitäten von Satzstellung markieren, Code -Abschluss, Refactoring, Debuggenusw. sind zu verschiedenen Abschlüssen erhältlich.

Geschichte

Die Entwicklung von Haxe begann im Oktober 2005. Das erste Alpha -Version wurde am 14. November 2005 veröffentlicht.^[11][12] Haxe 1.0 wurde im April 2006 mit Unterstützung für die Unterstützung für Adobe Flash, JavaScript, und Nekovm Programme. Die Unterstützung für PHP wurde 2008 hinzugefügt und 2009 wurde C ++ hinzugefügt. Weitere Plattformen wie C# und Java wurden 2012 mit einer Compilerüberholung hinzugefügt.

Haxe wurde von Nicolas Cannasse und anderen Mitwirkenden entwickelt und ursprünglich benannt haxe^[13] Weil es kurz, einfach und "hat ein X im Inneren", was der Autor humorvoll behauptet, für jede neue Technologie zum Erfolg zu werden.^[14]

Haxe ist der Nachfolger der Open-Source Aktionen 2 Compiler Mtasc,^[15] Auch von Nicolas Cannasse gebaut und unter dem freigelassen GNU Allgemeine öffentliche Lizenz Version 2 oder höher.

Compiler

Die Haxe -Sprache kann kompilieren Bytecode das kann direkt von der ausgeführt werden virtuelle Maschinen Es zielt auf sich ab. Es kann kompilieren zu Quellcode in C ++, JavaScript, Php, C#, Java, Python und Lua. Haxe hat auch einen Dolmetscher genannt bewerten.^[16] Der gleiche Dolmetscher wird auch verwendet, um Makros auszuführen, wodurch die Modifikation des Ast.

Diese Strategie des Zusammenstellens für mehrere Quellcodesprachen ist von der inspiriert Schreiben Sie einmal, rennen Sie irgendwohin Paradigma. Der Programmierer kann auch die beste Plattform für den Job auswählen. Typische HAXE-Programme werden auf allen Plattformen identisch ausgeführt Bedingte Zusammenstellung um zu verhindern, dass es auf anderen Plattformen zusammengestellt wird.

Der Haxe Compiler ist ein Compiler optimierenund verwendet Einbindung von Feld- und Funktionen, Schwanzrekursion Eliminierung, Konstante Faltung, Schlaufe abrollen und Dead Code Elimination (DCE) zur Optimierung der Laufzeitleistung kompilierter Programme.^[17] Der Haxe Compiler bietet Opt-In an Null-SafetyEs überprüft die Kompilierung der Zeit auf nullbare Werte.

Ziele

In Haxe werden unterstützte Plattformen als "Ziele" bezeichnet, die aus den folgenden Modulen bestehen:

• Die Compiler-Backends, die für die Generierung des jeweiligen Code verantwortlich sind.
• Die Laufzeitspezifische APIs, die über die Kernsprachunterstützung hinausgehen (Plattformziele).

Die folgende Tabelle dokumentiert Plattform und Sprachunterstützung in Haxe. Die Haxe -Sprache ermöglicht es Entwicklern, Zugriff auf viele Plattformfunktionen zu erhalten, aber Haxe ist keine vollständige Engine. Sie benötigen möglicherweise Frameworks, mit denen Inhalte für bestimmte Plattformen erstellt werden können.

Vorteile von Haxe

• Fähigkeit, mehrere Plattformen und Geräte mit derselben Sprache abzuzielen
• Fähigkeit, einen streng-typen Code zu verwenden
• Fähigkeit zur Verwendung von Makros (Syntax -Transformation), die mit Haxe -Sprache erfolgen können^[18]
• Sprachfunktionen wie z. Verlängerungsmethoden und Funktionelle Programmierung
• Die Laufzeitleistung von HAXE-Programmen ist mit vergleichbarer Geschwindigkeit für handgeschriebene Quellen.^[19]

Sprache

Haxe ist eine allgemeine Sprache, die unterstützt wird Objekt orientierte Programmierung, generische Programmierungund verschiedene Funktionelle Programmierung Konstrukte. Funktionen wie Iterationen, Ausnahmen, und Codereflexion sind auch integrierte Funktionen der Sprache und Bibliotheken. Ungewöhnlich unter Programmiersprachen enthält Haxe ein Typsystem, das beides ist stark und dynamisch. Der Compiler überprüft die Typen implizit mithilfe Typausschluss und geben Sie Kompilierzeitfehler an, ermöglicht dem Programmierer jedoch auch die Überprüfung des Typs und sich auf die dynamische Handhabung der Zielplattform. Alle nativen Ziel -APIs können verwendet werden.

Typ System

Haxe hat ein hoch entwickeltes und flexibles Typ. Die Art, die es anbietet, sind Klassen, Schnittstellen, Funktionsmethoden, anonyme Typen, Algebraische Datentypen (genannt Auflauf in Haxe) und abstrakte Typen. Parametrischer Polymorphismus ist mit Klassen, algebraischen Typen und Funktionstypen möglich, die Sprachunterstützung für generische Programmierung Basierend auf dem Typ -Löschen. Dies beinhaltet die Unterstützung für Varianz in Polymorphe Funktionen, obwohl nicht in Geben Sie Konstruktoren ein.

Das Typ System ist statisch Es sei denn, Anmerkungen für Dynamisches Typing sind vorhanden, zur Verwendung mit Zielen, die sie unterstützen. Geben Sie die Überprüfung ein folgt Nenne Typisierung mit Ausnahme von Anonyme Typen wo strukturelle Typisierung wird stattdessen verwendet. Endlich, Geben Sie Inferenz ein wird unterstützt, was variable Erklärungen ohne ermöglicht Geben Sie Anmerkungen ein.

Module und Namespaces

Alle Haxe -Code sind in Modulen organisiert, die unter Verwendung von Pfaden behandelt werden. Im Wesentlichen jeder .HX Die Datei repräsentiert ein Modul, das mehrere Typen enthalten kann. Zum Beispiel zum Erstellen des Typs A im Paket my.pack Wie gezeigt, sollte die Ordnerstruktur sein mein \ pack und die Datei könnte sein A.HX im Ordner Pack.

 // my/pack/a.hx Datei einreichen Paket mein.Pack; Klasse A {} 

In anderen Modulen können andere Typen durch Puting importiert werden importieren Aussagen unterhalb der Paketdefinition, z. my.pack.a;

Ein Modul kann mehrere Typen enthalten, z. B. die folgenden. Es ist möglich, jeweils einen Typ aus diesem Modul aus zu importieren import my.pack2.a;. Ein Typ kann sein PrivatgeländeIn diesem Fall kann nur das enthaltende Modul darauf zugreifen.

Paket mein.Pack2; Typedef A = {a:Saite} Privatgelände Typedef B = {b:Saite} 

Klassen

Klassen (Schlüsselwort Klasse) in Haxe ähneln denen in Java oder Typenkript. Ihre Felder können entweder Methoden, Variablen oder Eigenschaften sein, die jeweils statisch oder pro Instanz sind. Haxe unterstützt die Zubehör Öffentlichkeit und Privatgeländeund fortgeschrittenere Methoden zur Zugriffskontrolle, die mit Anmerkungen bezeichnet werden. Methoden und statische konstante Variablen können mit dem Schlüsselwort eingebaut werden in der Reihe. Felder können als markiert werden als Finale um eine Konstante zu deklarieren, die sofort oder im Konstruktor initialisiert werden muss und im Funktionsfall nicht geschrieben werden kann Finale Markiert in Unterklassen als nicht überdriftbar.

Schnittstellen In Haxe sind beispielsweise Java sehr ähnlich.

Schnittstelle Icreature {  Öffentlichkeit var Geburt:Datum;  Öffentlichkeit var Name:Saite;  Öffentlichkeit Funktion das Alter():Int; } Klasse Fliegen Geräte Icreature {  Öffentlichkeit var Geburt:Datum;  Öffentlichkeit var Name:Saite; 	  Öffentlichkeit Funktion das Alter():Int Rückkehr Datum.jetzt().Getreide() - Geburt.Getreide(); } 

Generika

Haxe unterstützt generische Programmierung. Das Folgende ist ein Beispiel für das Identitätsfunktion.

Funktion Identität<T> (arg:T):T { 	Rückkehr arg; } 

Aufzählte Typen

Aufzählte Typen sind ein wichtiges Merkmal der Sprache; Sie können Typparameter haben und rekursiv sein.^[20] Sie bieten grundlegende Unterstützung für Algebraische Datentypendie Einbeziehung von product typesin einer ähnlichen Weise ähnlich wie Haskell und Ml. EIN Schalter Ausdruck kann gelten Musteranpassung zu einem Umlaufwert, das elegante Lösungen für komplexe Programmierprobleme ermöglicht:

Auflauf Farbe { 	rot; 	grün; 	blau; 	RGB(r:Int, g:Int, b:Int); } Klasse Farben { 	statisch Funktion Toint(c:Farbe):Int { 		Rückkehr Schalter c { 			Fall rot: 0xff0000; 			Fall grün: 0x00ff00; 			Fall blau: 0x0000ff; 			Fall RGB(r, g, b): (r << 16) | (g << 8) | b; 		} 	} 	statisch Funktion gültige Kalls() { 		var Redint = Toint(Farbe.rot); 		var rgbint = Toint(Farbe.RGB(100, 100, 100)); 	} } 

Beispiele für parametrische Enumentypen sind die Option HAXE -Standardbibliothekstypen^[21] und entweder:^[22]

Auflauf Möglichkeit<T> {  Etwas(v:T);  Keiner; } Auflauf Entweder<L, R> {  Links(v:L);  Recht(v:R); } 

Haxe unterstützt auch Verallgemeinerte algebraische Datentypen (GADTS).^[23][24]

Anonyme Typen

Anonyme Typen werden definiert, indem ihre Struktur explizit bezeichnet, wobei eine Syntax verwendet wird, die der mathematischen rekordbasierten Darstellung eines Typs folgt. Sie können verwendet werden, um die strukturelle Typisierung für Funktionsargumente zu implementieren (siehe unten) und einen Alias ​​mit dem Schlüsselwort erhalten Typedef:

Typedef Aliasforanon = { a:Int, b:Saite, c:Schweben->Leere }; 

Funktionstypen

Funktionen sind erstklassige Werte in Haxe. Ihr Typ wird durch die Verwendung von Pfeilen zwischen Argumententypen und zwischen den Argumenttypen und dem Rückgabetyp als häufig in vielen funktionalen Sprachen bezeichnet. Anders als in prominenten Beispielen wie Haskell oder der Ml Sprachfamilie, nicht alle Funktionen sind Unary -Funktionen (Funktionen nur mit einem Argument), und in Haxe können Funktionen nicht sein teilweise angewendet pro Standard. Daher haben die folgenden Typsignaturen unterschiedliche Semantik als in den oben genannten Sprachen. Der Typ F1 ist eine Funktion, die a dauert Saite als Argumente und gibt einen Wert des Typs zurück Schweben.

Typen F1 undF2 bezeichnen den gleichen Typ außer dem F2 Verwendet ein gekennzeichneter Parameter, der für Abschluss- und Dokumentationszwecke nützlich ist.

Typen F4 und F5 Bezeichnen Sie den gleichen Typ. Beide sind binäre Funktionen, die eine binäre Funktion des Typs zurückgeben F3. Zum F5 Die Syntax zum Deklarieren eines Funktionstyps innerhalb eines Funktionstyps wird verwendet.

Typedef F1 = Saite -> Schweben; Typedef F2 = (Text: String) -> Schweben; Typedef F3 = (Punktzahl: Int, Textzeichenfolge) -> Schweben; Typedef F4 = (Punktzahl: Int, Textzeichenfolge) -> F3; Typedef F5 = (Punktzahl: Int, Textzeichenfolge) -> ((Punktzahl: Int, Textzeichenfolge) -> Schweben); 

Abstrakte Typen

Die neueste Ergänzung zum Haxe -Typ ist ein Konzept, das bezeichnet wird abstrakte Typen. Wie in Haxe verwendet, bezieht sich dies auf etwas anderes als ein konventionelles Zusammenfassung Typ. Sie werden verwendet, um Conversions zwischen den Typen implizit zu gestalten und die Wiederverwendung vorhandener Typen für bestimmte Zwecke zu ermöglichen, z. B. die Implementierung von Typen für Messeinheiten. Dies reduziert das Risiko, Werte desselben zugrunde liegenden Typs zu vermischen, jedoch mit unterschiedlichen Bedeutungen (z. B. Meilen gegenüber KM).

Das folgende Beispiel geht davon aus, dass das metrische System die Standardeinstellung ist, während eine Konvertierung in Meilen für Legacy -Daten erforderlich ist. Haxe kann automatisch Meilen in Kilometer umwandeln, aber nicht umgekehrt.

abstrakt Kilometer(Schweben) {  Öffentlichkeit Funktion Neu(v:Schweben) Dies = v; }   abstrakt Meile(Schweben) {  Öffentlichkeit Funktion Neu(v:Schweben) Dies = v;  @:zu Öffentlichkeit in der Reihe Funktion Tokilometer():Kilometer Rückkehr (Neu Kilometer (Dies / 0,62137)); }   Klasse Prüfen {  statisch var km:Kilometer;  statisch Funktion hauptsächlich() {  var One100miles = Neu Meile(100);  km = One100miles;    verfolgen(km); // 160.935  } } 

Wie das Beispiel zeigt, ist für die Zuordnung "km = ein100 Meilen" keine explizite Konvertierung erforderlich; das Richtige tun.

Strukturelle Typisierung

In vielen funktionalen Programmiersprachen,, strukturelle Typisierung spielt eine wichtige Rolle. Haxe setzt es in Gegenwart anonymer Typen an, wobei das verwendet wird Nominative Typisierung von Objekt orientierte Programmierung, wenn nur genannte Typen beteiligt sind. Anonyme Typen in Haxe sind analog zu den impliziten Schnittstellen der Sprache gehen zum Schreiben. Im Gegensatz zu GO -Schnittstellen ist es möglich, einen Wert mit einem anonymen Typ zu konstruieren.

Klasse Foobar { 	Öffentlichkeit var Foo:Int; 	Öffentlichkeit var Bar:Saite; 	Öffentlichkeit Funktion Neu() { 		Foo = 1; 		Bar = "2"; 	} 	Funktion Anyfoobar(v: {Foo:Int, Bar:Saite}) 		verfolgen(v.Foo); 	statisch Funktion Prüfung() { 		var FB = Neu Foobar(); 		FB.Anyfoobar(FB); 		FB.Anyfoobar({{Foo: 123, Bar: "456"}); 	} } 

Interne Architektur

Compiler

Der Haxe -Compiler ist in eine Frontend- und mehrere Backends unterteilt. Der Frontend erstellt eine Zusammenfassung Syntaxbaum (AST) aus dem Quellcode und führt die Typprüfung durch, Makroerweiterung, und Optimierung der Ast. Die verschiedenen Backends Übersetzen Der verarbeitete AST in Quellcode oder generiert Bytecode, abhängig von ihrem Ziel.

Der Compiler ist in geschrieben Ocaml. Es kann im Servermodus ausgeführt werden, um Code-Fertigstellung zu erhalten Integrierte Entwicklungsumgebungen (IDE) und einen Cache beibehalten, um die Schnellkompilierung weiter zu erstellen.^[25]

Siehe auch

• Vergleich der IDE -Auswahl für HAXE -Programmierer
• Dart (Programmiersprache)
• NIM (Programmiersprache)
• OPA (Programmiersprache)
• Clojure
• CoffeeScript
• Typoskript
• Scala (Programmiersprache)
• Vala (Programmiersprache)
• Emscripten
• Openfl

Verweise

Externe Links

• Offizielle Website