Haxe — Wikipédia

Haxe
Logo.
Date de première version
Auteur Nicolas Cannasse
Dernière version 4.3.4 ()[1]Voir et modifier les données sur Wikidata
Typage Dynamique, statique, nominatif
Influencé par Java, OCaml, ActionScript
Écrit en OCamlVoir et modifier les données sur Wikidata
Système d'exploitation Android, iOS, Windows, GNU/Linux, Mac OS X
Licence GNU GPL et licence MIT
Site web haxe.org
Extensions de fichiers .hx
modifier Consultez la documentation du modèle

Haxe est le nom d'un langage de programmation, multi-paradigme, multiplate-forme, haut niveau et celui d'un compilateur utilisé pour produire des applications pour de nombreuses plates-formes différentes à partir d'un seul code source[2],[3],[4],[5],[6]. C'est aussi le nom d'un logiciel gratuit et open source distribué sous la licence GPLv2. La bibliothèque standard est disponible sous la licence MIT.

Haxe inclut un ensemble de fonctions communes qui sont supportées sur toutes les plates-formes, tels que les types de données numériques, textuelles, tabulaires et binaires ainsi que certains formats de fichier communs[6],[7]. Haxe inclut aussi des interfaces de programmation (API) spécifiques à certaines plates-formes notamment pour Adobe Flash, C++, PHP[3],[8].

Le code écrit dans le langage Haxe serait compilable "source à source" vers un script écrit en ActionScript3, JavaScript, Java, C++, C#, PHP, Python, Lua[9] ou Node.js[10],[3],[7]. On pourrait aussi utiliser Haxe pour produire ce qu'on appellerait du "small web format" (SWF) ou du "bytecode Neko" ou du "HashLink"[11].

Les principaux utilisateurs d'Haxe incluent des développeurs chez les sociétés BBC, Coca-Cola, Disney, Hasbro, Mattel, Nickelodeon, Prezi, TiVo et Zynga[12],[13]. OpenFL (en) et Flambe sont des frameworks Haxe populaires permettant de créer du contenu multiplate-forme à partir d'un seul code source[13],[14].

Architecture[modifier | modifier le code]

Langage unifié[modifier | modifier le code]

L'aspect le plus unique de l'architecture d'Haxe fut la décision du support de Flash, de JavaScript ainsi que des scripts côté serveur avec un langage unifié[15],[16]. Dans des projets de développement web traditionnels, les développeurs utilisent différents langages pour construire une application web intégrée[15],[16].

  • PHP ou un autre langage côté serveur pour générer l'HTML
  • JavaScript pour manipuler l'HTML côté client
  • ActionScript pour des sections graphiques construites avec Flash

Haxe a pour origine de supporter tous ses aspects en un seul langage, et de simplifier la logique de communication entre eux[15],[16],[17]. De ce fait, la logique de l'application n'a pas besoin de gérer l'implémentation de communications.

Les buts originaux de Haxe sont[15] :

  • Construire un langage plus puissant qu'ActionScript 2 et 3
  • Être capable de facilement traduire une application d'ActionScript en Haxe
  • Être capable d'utiliser ce langage pour Flash 6, 7, 8, et 9
  • Être capable d'utiliser ce langage pour du JavaScript-Ajax
  • Être capable d'utiliser ce langage pour de la programmation côté serveur à la place de PHP ou Java

Compilateur[modifier | modifier le code]

Le compilateur est divisé en un frontal et en plusieurs backends. Le frontal crée un arbre syntaxique abstrait (AST) à partir du code source et effectue la vérification des types, l’expansion des macros et l'optimisation de l'AST. Les différents backends traduisent l'AST ainsi traité en code source ou bytecode selon leur cible.

Le compilateur est écrit en OCaml. Il peut être utilisé en mode serveur pour fournir la complétion du code pour les environnements de développement (IDE) ainsi que pour maintenir une mémoire cache afin d’accélérer la compilation[18].

Cible[modifier | modifier le code]

En Haxe, les plates-formes supportées sont connus sous le nom de "cibles"[19]. Il s'agit de modules Haxe qui fournissent un accès aux API internes pour les parties backend du compilateur qui sont responsables de la génération du code ou bytecode correspondant.

  • Les cibles bytecode produisent du bytecode exécutable (Neko, SWF, SWF8), pouvant être exécuté par un environnement d'exécution (Neko VM, Adobe Flash Player, Adobe AIR). L'API Haxe et les API spécifique à la plate-forme sont disponibles.
  • Les cibles langages produisent du code source (AS3, C++, C#, Java). La plupart des codes sources doivent être compilés grâce à des compilateurs externes pour produire des fichiers exécutables (Flex SDK, GNU Compiler Collection (GCC), Microsoft Visual C++, Framework .NET, compilateur Java). Le code JavaScript et PHP peuvent être exécutés directement, puisque leur environnement d'exécution utilisent la compilation à la volée. Le code inline écrit dans le langage cible peut être inséré à tout moment dans l'application, impliquant le support de l'intégralité de l'API de la plate-forme; incluant des fonctionnalités manquantes de l'API Haxe.
  • Les modules externes sont des définitions de type (extern class Haxe) décrivant les types d'une API ou bibliothèque native, de façon que le compilateur Haxe puisse utiliser la vérification de type statique.

Développement[modifier | modifier le code]

Le développement d'Haxe a commencé en 2005[20]. La première version béta fut disponible en . Haxe 1.0 est sortie le avec le support des cibles Adobe Flash, JavaScript et Neko.

Haxe est le successeur du compilateur open-source MTASC (en) aussi créé par Nicolas Cannasse[21], et est disponible sous la licence GNU General Public Licence. La connaissance de l'OCaml n'est pas requise pour développer des applications grâce à Haxe.

Plates-formes supportées[modifier | modifier le code]

La langage Haxe peut être compilé en du bytecode pour différentes machines virtuelles, telles que l'Adobe Flash Player et la NekoVM et générer du code source pour des langages tels que Javascript et Python.

La stratégie de compiler vers de multiples langages de programmation est inspirée du paradigme « écrire une seule fois, exécuter partout ». Cela permet au programmeur de choisir les meilleurs options pour sa tache.

Générateur Sortie Plate-forme Utilisation Depuis
AVM1[22] byte code Adobe Flash Player 6+ Bureau, navigateur 2005 (alpha)
AVM2[22] byte code Adobe Flash Player 9+, Adobe AIR, Tamarin VM Bureau, navigateur, serveur 2005 (alpha)
ActionScript 3[22] source Adobe Flash Player 9+ Serveur, bureau 2007 (1.12)
C++ (hxcpp)[22] source Windows, Linux, macOS Serveur, bureau, CLI 2009 (2.04)
C++[22] source Android, Apple iOS, Palm webOS Mobile 2009 (2.04)
C#[22] source .NET Framework Serveur, bureau, mobile 2012 (2.10)
HashLink[22] source HashLink Serveur, bureau 2016 (3.3)
Java[22] source Java Serveur, bureau 2012 (2.10)
JavaScript[22] source HTML5, NodeJS, PhoneGap Serveur, bureau, navigateur, mobile 2006 (beta)
Neko[22] byte code NekoVM Serveur, bureau, CLI 2005 (alpha)
PHP[22] source PHP Serveur 2008 (2.0)
Python[22] source Python CLI, web, bureau 2014 (3.2)
Lua[22] source Lua CLI, web, bureau, mobile 2016 (3.3)

Langage[modifier | modifier le code]

Haxe est un langage supportant la programmation orientée objet, la programmation générique et diverses constructions de programmation fonctionnelle. Des fonctionnalités telles que les itérations, les exceptions ou encore la réflexion sont des fonctionnalités de bases du langage. Haxe possède un système de types à la fois fort et dynamique. Le compilateur vérifiera implicitement les types et donnera des erreurs de compilations. Cela donne aussi la possibilité aux programmeurs d'ignorer la vérification des types et d'utiliser le typage dynamique de la plate-forme ciblée.

Typage[modifier | modifier le code]

Haxe possède un système de types flexible et sophistiqué. Les types disponibles sont les classes, les interfaces, les fonctions ainsi que des types anonymes, des types algébrique de données (enum) et des types abstraits (abstract). Le polymorphisme paramétrée est possible pour les classes, les fonctions et les types algébriques, permettant ainsi la programmation générique. La variance dans les fonctions polymorphiques est ainsi supportée.

Par défaut, le typage est statique sauf si des annotations de typage dynamique sont présentes, pour être utilisées avec une cible le supportant. La vérification des types utilise le système nominatif des types à l'exception des types anonymes, où le système structurel des types est utilisé. Enfin, l'inférence des types est supportée, permettant de déclarer une variable sans annotation de type.

Classes[modifier | modifier le code]

Les classes (mot-clef class) Haxe sont similaires à celle de Java ou d'ActionScript 3. Leurs champs peuvent être des méthodes, des variables ou des propriétés, chacun soit statique soit propre à chaque instance. Haxe supporte les accesseurs public et private, ainsi que des méthodes plus avancées pour le contrôle d'accès spécifiées par des annotations. Les méthodes et les variables constantes statiques peuvent utiliser l'extension inline grâce au mot-clef inline.

Les interfaces en Haxe sont très similaires à celles, par exemple de Java.

interface ICreature {     public var dateDeNaissance:Date;     public var nom:String;      public function age():Int; }  class Mouche implements ICreature {     public var dateDeNaissance:Date;     public var nom:String;      public function age():Int return Date.now().getFullYear() - dateDeNaissance.getFullYear(); }

Types énumérés[modifier | modifier le code]

Les types énumérés sont une part importante du langage; ils peuvent être paramétrés et être récursifs. Ils fournissent un support de base pour les types algébrique de données, permettant d'inclure des types produit, similairement à Haskell et ML. Un switch peut appliquer un filtrage par motif aux valeurs énumérées, permettant des solutions élégantes à des problèmes complexes.

enum Couleur {     Rouge;     Vert;     Bleu;     RGB( r : Int, g : Int, b : Int ); }  class Couleurs {     static function versInt ( c : Couleur ) : Int {         return switch ( c ) {             case Rouge: 0xFF0000;             case Vert: 0x00FF00;             case Bleu: 0x0000FF;             case RGB(r, g, b): (r << 16) | (g << 8) | b;         }     }     static function appelsPermis() {         var rouge = versInt(Couleur.Rouge);         var rgbint = versInt(Couleur.RGB(100, 100, 100));     } }

Des exemples de types énumérés paramétrés sont disponibles dans la bibliothèque standard Haxe, tel que les types Option[23] et Either[24].

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

Haxe supporte aussi les types algébrique généralisé[25].

Types anonymes[modifier | modifier le code]

Les types anonymes sont définis en indiquant explicitement leur structure. Ils peuvent être utilisés pour implémenter un typage structurel des arguments des fonctions (voir plus bas) et recevoir un alias avec le mot-clef typedef.

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

Types fonctions[modifier | modifier le code]

En Haxe, les fonctions sont des objets de première classe. Leur type est noté en utilisant des flèches entre les types des arguments et entre le(s) type(s) argument et le type de retour, comme présent de nombreux langages de programmation fonctionnelle. Cependant, contrairement à Haskell et aux langages de la famille ML, toutes les fonctions ne sont pas unaires (fonction avec un unique argument). Donc, les signatures des types suivants possèdent des sémantiques différentes que dans les langages précédemment mentionnés. Le type F est une fonction qui prend en argument un entier (Int) et une chaîne de caractères (String) et retourne une valeur de type réel (Float).

La même notation dans un langage avec uniquement des fonctions unaires ferait référence à une fonction prenant en paramètre un Int et retournerait une fonction de type String->Float.

Les types F2 et F3 correspondent au même type. Ce sont des fonctions binaires qui retournent une fonction binaire de type F. Pour F3, la syntaxe pour définir une type fonction dans un type fonction est utilisé.

typedef F = Int->String->Float;  typedef F2 = Int->String->F; typedef F3 = Int->String->(Int->String->Float);

Types abstraits[modifier | modifier le code]

Le dernier ajout au système de types d'Haxe est le concept des types abstraits. En Haxe, ils diffèrent des types abstraits conventionnels. Ils servent à rendre implicites les conversions entre différent types, permettant de réutiliser des types existants dans des buts spécifiques, tels que des types pour les unités de mesure. Cela permet de réduire fortement le mélange des valeurs de même type mais avec des sémantiques différentes (par exemple, miles et kilomètres).

L'exemple suivant suppose que le système métrique est le système par défaut, nécessitant une conversion de miles vers kilomètres pour les données existantes du mauvais format. Cet exemple permet donc de convertir automatiquement des miles en kilomètres mais pas l'inverse.

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

Comme l'exemple le montre, aucune conversion explicite n'est requise pour effectuer l'assignation km = centMiles.

Typage structurel[modifier | modifier le code]

Dans de nombreux langages de programmation fonctionnelle, le typage structurel joue un rôle important. Haxe l'applique via les types anonymes, n'utilisant le système nominatif de types de la programmation orientée objet que lorsque les types nommés sont utilisés. Les types anonymes d'Haxe sont analogues aux interfaces implicites du langage Go. Contrairement aux interfaces du Go, il est possible de construire une valeur à partir d'un type anonyme.

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"});    } }

Voir aussi[modifier | modifier le code]

Aussi sur la plate-forme Haxe :

Autres langages multiplate-forme :

Références[modifier | modifier le code]

  1. ↑ a et b « Release 4.3.4 », (consulté le )
  2. ↑ (en) « Nicolas' annoucement of spelling change on Haxe official mail list », sur groups.google.com, (consulté le )
  3. ↑ a b et c Ponticelli, Franco et McColl-Sylvester, Lee, Professional haXe and Neko, Wiley Technology Pub, , 619 p. (ISBN 978-0-470-12213-6 et 0-470-12213-7, OCLC 896076519, lire en ligne)
  4. ↑ Ivanov, Michael., Away3D 3.6 Cookbook., Packt Pub, , 480 p. (ISBN 978-1-84951-281-7 et 1-84951-281-7, OCLC 797916638, lire en ligne)
  5. ↑ (en) Lars Doucet, « Haxe/OpenFL for home game consoles », Gamasutra,‎ (lire en ligne)
  6. ↑ a et b David Mouton, « Sortie de Haxe 3.2.0 », LinuxFr,‎ (lire en ligne)
  7. ↑ a et b (en) « Introduction to the Haxe Standard Library », sur haxe.org
  8. ↑ (en) « Target Specific APIs, Introduction to the Haxe Standard Library », sur haxe.org
  9. ↑ (en) Justin Donaldson, « Hello Lua », sur haxe.org,
  10. ↑ (en) « hxnodejs », sur lib.haxe.org,
  11. ↑ (en) « The New Haxe Target: HashLink In Depth », sur haxe.org,
  12. ↑ (en) « Who uses Haxe », sur haxe.org (consulté le )
  13. ↑ a et b (en) Lars Doucet, « Dear Adbode: Support Haxe, save your Tools », Gamasutra,‎ (lire en ligne)
  14. ↑ (en) « All haxelib (by popularity) », sur lib.haxe.org (consulté le )
  15. ↑ a b c et d Arnold, Wade., Balkan, Aral., Cannasse, Nicolas. et Grden, John., The Essential Guide to Open Source Flash Development, Chris Allen, Wade Arnold, Aral Balkan, Nicolas Cannasse, John Grden, Moses Gunesch, Marc Hughes, R. Jon MacDonald, Andy Zupko, , 350 p. (ISBN 978-1-4302-0994-2 et 1-4302-0994-1, OCLC 929006012, lire en ligne)
  16. ↑ a b et c (en) Nicolas Canasse, « Haxe interview », Io Programmo,‎ , p. 1-6 (lire en ligne)
  17. ↑ Fisher, Matt,, HTML5 for flash developers, Packt Pub, , 322 p. (ISBN 978-1-84969-333-2 et 1-84969-333-1, OCLC 871666029, lire en ligne)
  18. ↑ (en) « Completion server », sur haxe.org (consulté le )
  19. ↑ « Compilateur Haxe », sur old.haxe.org (consulté le )
  20. ↑ (en) « Haxe 3.4.2 », sur github.com (consulté le )
  21. ↑ (en) John Grden, Patrick Mineault, Aral Balkan, Marc Hughes et Wade Arnold, The Essential Guide to Open Source Flash Development, Apress, , 350 p. (ISBN 978-1-4302-0994-2 et 1-4302-0994-1, lire en ligne), Chapter 9 (Using Haxe)
  22. ↑ a b c d e f g h i j k l et m (en) « Compiler targets », sur haxe.org (consulté le )
  23. ↑ (en) « HaxeFoundation/haxe », sur GitHub (consulté le )
  24. ↑ (en) « HaxeFoundation/haxe », sur GitHub (consulté le )
  25. ↑ (en) « Language Features », sur haxe.org (consulté le )
v · m
Analyse statique de programmes
Compilateur source à source
Concepts
Débogueur
Générateur de documentation
Éditeurs (comparaison (en))
Moteur
Framework
Technologie associée
Gestionnaire de paquets
Côté serveur
Test unitaire
Personnalité
Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Haxe&oldid=214085929 ».