Haxe - Haxe

Haxe

Paradigma	Multi-paradigma
Vývojář	Nadace Haxe
Poprvé se objevil	2005 ; Před 16 lety ( 2005 )
Stabilní uvolnění	4.2.3  / 1. července 2021 ; před 3 měsíci ( 1. července 2021 )
Kázeň při psaní	Statické , dynamické prostřednictvím anotací, nominální
Implementační jazyk	OCaml
Plošina	ARM ; IA-32 , x86-64
OS	Android , iOS ; Linux , macOS , Windows
Licence	GPL 2.0, knihovna: MIT
Rozšíření názvu souboru	.hx, .hxml
webová stránka	haxe .org
Ovlivněn
EcmaScript , OCaml , Java , JavaScript , C ++ , PHP , C# , Python , Lua , ActionScript , NekoVM

Haxe je otevřený zdrojový multiplatformní programovací jazyk a kompilátor, který dokáže vytvářet aplikace a zdrojový kód pro mnoho různých výpočetních platforem z jedné kódové základny. Je to bezplatný a open-source software , vydávaný pod licencí MIT . Kompilátor napsaný v OCaml je vydán pod licencí GNU General Public License (GPL) verze 2.

Haxe obsahuje sadu funkcí a standardní knihovnu podporovanou na všech platformách , jako jsou číselné datové typy , řetězce , pole , mapy , binární , reflexní , matematické, HTTP , souborový systém a běžné formáty souborů . Haxe také obsahuje pro každý cíl kompilátoru API specifická pro platformu. Kha , OpenFL a Heaps.io jsou populární rámce Haxe, které umožňují vytváření multiplatformního obsahu z jedné kódové základny.

Haxe vznikl s myšlenkou podpory programování na straně klienta a serveru v jednom jazyce a zjednodušení komunikační logiky mezi nimi. Kód napsaný v jazyce haXe může být sestaven do JavaScriptu , C ++ , Javu , JVM , PHP , C # , Python , Lua a Node.js . Haxe může také přímo kompilovat bytecode SWF , HashLink a Neko a také běží v interpretovaném režimu.

Haxe podporuje externí (definiční soubory), které mohou obsahovat informace o typu stávajících knihoven k popisu interakce specifické pro cíl způsobem bezpečným pro daný typ, jako například hlavičkové soubory C ++ mohou popisovat strukturu existujících souborů objektů . To umožňuje použít hodnoty definované v souborech, jako by to byly staticky napsané Haxe entity. Kromě externích zařízení existují další řešení pro přístup k nativním možnostem každé platformy.

Mnoho populárních IDE a editorů zdrojových kódů má k dispozici podporu pro vývoj Haxe . Haxe Foundation oficiálně nedoporučuje žádné konkrétní vývojové prostředí ani sadu nástrojů, ačkoli VS Code , IntelliJ IDEA a HaxeDevelop mají pro vývoj Haxe největší podporu. Základní funkce zvýraznění syntaxe , dokončení kódu , refaktorování , ladění atd. Jsou k dispozici v různé míře.

Dějiny

Vývoj Haxe začal v říjnu 2005. První beta verze byla vydána v únoru 2006. Haxe 1.0 byl vydán v dubnu 2006 s podporou programů Adobe Flash , JavaScript a Neko . Podpora pro PHP byla přidána v roce 2008 a C ++ byla přidána v roce 2009. Další platformy jako C# a Java byly přidány s generální opravou kompilátoru v roce 2012.

Haxe byl vyvinut Nicolasem Cannasse a dalšími přispěvateli a původně se jmenoval haXe, protože byl krátký, jednoduchý a „má uvnitř X“, což autor vtipně prohlašuje, že je potřeba, aby každá nová technologie byla úspěšná.

Haxe je nástupcem kompilátoru MTASC s otevřeným zdrojovým kódem ActionScript 2 , který také vytvořil Nicolas Cannasse a je vydán pod licencí GNU General Public License verze 2 nebo novější.

Překladač

Jazyk Haxe lze kompilovat do bajtkódu, který lze spustit přímo virtuálními počítači, na které cílí. Lze jej kompilovat do zdrojového kódu v jazycích C ++ , JavaScript , PHP , C# , Java , Python a Lua . Haxe má také tlumočníka jménem eval . Tentýž tlumočník se také používá při kompilaci ke spouštění maker, která umožňují úpravu AST .

Tato strategie kompilace do více jazyků zdrojového kódu je inspirována paradigmatem write once, run anywhere . Programátor také umožňuje vybrat nejlepší platformu pro danou úlohu. Typické programy Haxe běží identicky na všech platformách, ale vývojáři mohou určit kód pro konkrétní platformu a použít podmíněné kompilace, aby se zabránilo kompilaci na jiných platformách.

Kompilátor Haxe je optimalizační překladač a k optimalizaci běhu kompilovaných programů využívá vkládání polí a funkcí , eliminaci rekurze ocasu , konstantní skládání , rozbalování smyčky a odstraňování mrtvého kódu (DCE). Kompilátor Haxe nabízí opt-in null-safety , kontroluje čas kompilace pro hodnoty s možnou hodnotou null .

Cíle

V Haxe jsou podporované platformy známé jako „cíle“, které se skládají z následujících modulů:

• Kompilátory-backendy, které jsou zodpovědné za generování příslušného kódu.
• Rozhraní API specifická za běhu, která přesahují základní jazykovou podporu (platformy-cíle).

Následující tabulka dokumentuje platformu a jazykovou podporu v Haxe. Jazyk Haxe umožňuje vývojářům získat přístup k mnoha funkcím platformy, ale Haxe není plně vybavený motor, možná budou potřebovat rámce, které umožňují vytvářet obsah pro určité platformy.

Vzhledem k tomu, že Haxe verze 1.12 (2007) existoval zdrojový cíl ActionScript 3 (pro Adobe FlashPlayer), byl ve verzi 4.0 z Haxe odstraněn.

Výhody pro Haxe

• Možnost cílit na více platforem a zařízení pomocí stejného jazyka
• Schopnost používat striktně zadaný kód
• Schopnost používat makra (transformace syntaxe), která lze provést pomocí jazyka Haxe
• Přidané jazykové funkce, jako jsou metody rozšíření a funkční programování
• Běhový výkon programů Haxe je srovnatelný s ručně psanými zdroji.

Jazyk

Haxe je univerzální jazyk podporující objektově orientované programování , generické programování a různé funkční programovací konstrukce. Funkce, jako jsou iterace , výjimky a reflexe kódu, jsou také integrovanými funkcemi jazyka a knihoven. Neobvyklé mezi programovacími jazyky, Haxe obsahuje typový systém, který je silný i dynamický . Kompilátor bude implicitně kontrolovat typy pomocí odvozování typů a dávat chyby při kompilaci, ale také umožňuje programátorovi obejít typovou kontrolu a spoléhat se na dynamické zpracování typů na cílové platformě. Lze použít všechna nativní cílová rozhraní API.

Typový systém

Haxe má propracovaný a flexibilní typový systém. Druhy typů, které nabízí, jsou třídy, rozhraní, typy metod metod, anonymní typy, algebraické datové typy (ADT, nazývané enum v Haxe) a abstraktní typy. Parametrický polymorfismus je možný u tříd, ADT a typů funkcí, což poskytuje jazykovou podporu pro generické programování založené na mazání typů. To zahrnuje podporu pro odchylky v polymorfních funkcích , i když ne v typových konstruktérech .

Typ systému je statická , pokud anotace pro dynamické psaní jsou přítomny, pro použití s cíli, které je podporují. Kontrola typu se řídí nominálním typováním s výjimkou anonymních typů, kde se místo toho používá strukturální psaní . Nakonec je podporováno odvozování typů , což umožňuje deklarace proměnných bez anotací typů .

Moduly a obory názvů

Veškerý kód Haxe je organizován v modulech, které jsou adresovány pomocí cest. V podstatě každý soubor .hx představuje modul, který může obsahovat několik typů. Chcete -li například vytvořit typ Av balíčku my.pack, jak je uvedeno, struktura složek by měla být moje \ pack a soubor by mohl být A.hx v balíčku složek .

 // file my/pack/A.hx
package my.pack;

class A {}

V jiných modulech lze importovat jiné typy umístěním importpříkazů pod definici balíčku, např import my.pack.A; . Modul může obsahovat více typů, například následující. Z tohoto modulu je možné importovat jeden typ najednou pomocí import my.pack2.A;. Typ může být private, v takovém případě k němu má přístup pouze jeho modul obsahující.

package my.pack2;

typedef A = {a:String}
private typedef B = {b:String}

Třídy

Třídy (klíčová slova class) v Haxe jsou podobné těm v Javě nebo TypeScriptu. Jejich pole mohou být buď metody, proměnné nebo vlastnosti, každé statické nebo pro každou instanci. Haxe podporuje přístupové prvky publica privatepokročilejší metody pro řízení přístupu, které jsou označeny pomocí poznámek. Metody a proměnné statické konstanty lze inline pomocí klíčového slova inline. Pole lze označit tak, finalaby deklarovaly konstantu, která musí být inicializována okamžitě nebo v konstruktoru a do které nelze zapisovat, v případě funkce finalbude v podtřídách označena jako nepřepisovatelná.

Rozhraní v Haxe jsou velmi podobná těm, například v Javě.

interface ICreature {
    public var birth:Date;
    public var name:String;

    public function age():Int;
}

class Fly implements ICreature {
    public var birth:Date;
    public var name:String;
	
    public function age():Int return Date.now().getFullYear() - birth.getFullYear();
}

Generika

Haxe podporuje generické programování . Následuje příklad funkce identity .

function identity<T>(arg:T):T {
	return arg;
}

Výčtové typy

Výčtové typy jsou důležitou vlastností jazyka; mohou mít parametry typu a být rekurzivní. Poskytují základní podporu pro algebraické datové typy a umožňují zahrnutí typů produktů podobným způsobem jako Haskell a ML . switchVýraz může použít ve stejném vzoru na hodnotu výčtu, který umožňuje elegantní řešení složitých problémů programování:

enum Color {
	red;
	green;
	blue;
	rgb(r:Int, g:Int, b:Int);
}

class Colors {
	static function toInt(c:Color):Int {
		return switch c {
			case red: 0xFF0000;
			case green: 0x00FF00;
			case blue: 0x0000FF;
			case rgb(r, g, b): (r << 16) | (g << 8) | b;
		}
	}

	static function validCalls() {
		var redint = toInt(Color.red);
		var rgbint = toInt(Color.rgb(100, 100, 100));
	}
}

Příklady typů parametrických výčtů jsou standardní typy knihoven Haxe Option a Buď:

enum Option<T> {
    Some(v:T);
    None;
}

enum Either<L, R> {
    Left(v:L);
    Right(v:R);
}

Haxe také podporuje generalizované algebraické datové typy (GADT).

Anonymní typy

Anonymní typy jsou definovány explicitním označením jejich struktury pomocí syntaxe, která následuje po matematické reprezentaci typu na základě záznamů. Lze je použít k implementaci strukturálního psaní pro argumenty funkcí (viz níže) a lze jim dát alias s klíčovým slovem typedef:

typedef AliasForAnon = { a:Int, b:String, c:Float->Void };

Typy funkcí

Funkce jsou v Haxe prvotřídními hodnotami. Jejich typ je označován pomocí šipek mezi typy argumentů a mezi typy argumentů a návratovým typem, což je běžné v mnoha funkčních jazycích. Na rozdíl od prominentních příkladů, jako je Haskell nebo jazyková rodina ML , však nejsou všechny funkce unárními funkcemi (funkce pouze s jedním argumentem) a v Haxe nelze funkce ve výchozím nastavení částečně použít . Následující podpisy typů mají tedy jinou sémantiku než ve výše uvedených jazycích. Typ F1je funkce, která bere Stringargumenty jako a vrací hodnotu typu Float.

Typy F1a F2 označení stejného typu, kromě toho, že F2používá označený parametr, který je užitečný pro účely dokončení a dokumentace.

Typy F4a F5označte stejný typ. Obě jsou binární funkce, které vracejí binární funkci typu F3. Pro F5syntaxi k deklarování typu funkce v rámci typu funkce se používá.

typedef F1 = String -> Float;
typedef F2 = (text:String) -> Float;

typedef F3 = (score:Int, text:String) -> Float;
typedef F4 = (score:Int, text:String) -> F3;
typedef F5 = (score:Int, text:String) -> ((score:Int, text:String) -> Float);

Abstraktní typy

Nejnovějším přírůstkem do systému typu Haxe je koncept nazývaný abstraktní typy . Jak se používá v Haxe, toto odkazuje na něco jiného než konvenční abstraktní typ . Používají se k implicitním převodům mezi typy, což umožňuje opětovné použití stávajících typů pro konkrétní účely, jako je implementace typů pro jednotky měření. To výrazně snižuje riziko záměny hodnot stejného podkladového typu, ale s různým významem (např. Míle vs. km).

Následující příklad předpokládá, že metrický systém je výchozí, zatímco u starších dat je potřeba převod na míle. Haxe dokáže automaticky převádět míle na kilometry, ale ne naopak.

abstract Kilometer(Float) {
    public function new(v:Float) this = v;
}
 
abstract Mile(Float) {
    public function new(v:Float) this = v;
    @:to public inline function toKilometer():Kilometer return (new Kilometer (this / 0.62137));
}
 
class Test {
  static var km:Kilometer;
  static function main(){
    var one100Miles = new Mile(100);
    km = one100Miles;
 
    trace(km); // 160.935
  }
}

Jak ukazuje příklad, pro přiřazení „km = one100Miles;“ není nutná žádná explicitní konverze. udělat správnou věc.

Strukturální psaní

V mnoha funkčních programovacích jazycích hraje hlavní roli strukturální psaní . HaXe ho zaměstnává v přítomnosti anonymních typů, pomocí jmenovaný psát o objektově orientovaného programování , když jsou zapojeny pouze pojmenované typy. Anonymní typy v Haxe jsou analogické implicitním rozhraním jazyka Přejít na psaní. Na rozdíl od rozhraní Go je možné vytvořit hodnotu pomocí anonymního typu.

class FooBar {
	public var foo:Int;
	public var bar:String;

	public function new() {
		foo = 1;
		bar = "2";
	}

	function anyFooBar(v:{foo:Int, bar:String})
		trace(v.foo);

	static function test() {
		var fb = new FooBar();
		fb.anyFooBar(fb);
		fb.anyFooBar({foo: 123, bar: "456"});
	}
}

Vnitřní architektura

Překladač

Kompilátor Haxe je rozdělen na jeden frontend a více backendů. Frontend vytvoří ze zdrojového kódu abstraktní strom syntaxe (AST) a na AST provede kontrolu typu, rozšíření makra a optimalizaci . Různé backendy překládají zpracovaný AST do zdrojového kódu nebo generují bytecode , v závislosti na jejich cíli.

Kompilátor je napsán v OCaml . Lze jej spustit v režimu serveru, aby bylo zajištěno dokončení kódu pro integrovaná vývojová prostředí (IDE) a udržování mezipaměti, což dále zrychlí kompilaci.

Viz také

• Porovnání možností IDE pro programátory Haxe
• Dart (programovací jazyk)
• Nim (programovací jazyk)
• Opa (programovací jazyk)
• Clojure
• CoffeeScript
• Strojopis
• Scala (programovací jazyk)
• Vala (programovací jazyk)
• Emscripten
• OpenFL

Reference

externí odkazy

• Oficiální webové stránky