Haxe | ||
![]() | ||
Fecha de la primera versión | 16 de mayo de 2006 | |
---|---|---|
Autor | Nicolas cannasse | |
Última versión | 4.2.1 (26 de febrero de 2021) | |
Mecanografía | Dinámico , estático , nominativo | |
Influenciado por | Java , OCaml , ActionScript | |
Escrito en | OCaml | |
Sistema de explotación | Android , iOS , Windows , GNU / Linux , Mac OS X | |
Licencia | Licencia GNU GPL y MIT | |
Sitio web | haxe.org | |
Extensiones de archivo | .hx | |
Haxe es el nombre de un lenguaje de programación , multi-paradigma , multiplataforma , de alto nivel y el de un compilador utilizado para producir aplicaciones para muchas plataformas diferentes de una sola fuente. También es el nombre de un software gratuito y de código abierto distribuido bajo la licencia GPLv2 . La biblioteca estándar está disponible bajo la licencia MIT .
Haxe incluye un conjunto de funciones comunes que son compatibles con todas las plataformas , como tipos de datos numéricos , de texto , tabulares y binarios , así como algunos formatos de archivo comunes . Haxe también incluye interfaces de programación (API) específicas para ciertas plataformas, en particular para Adobe Flash , C ++ , PHP .
El código escrito en un lenguaje Haxe podría ser compilado "una fuente a" a un guión escrito en ActionScript3 , JavaScript , Java , C ++ , C # , PHP , Python , Lua o Node.js . También podríamos utilizar Haxe para producir lo que llamaríamos " formato web pequeña " ( SWF ) o " Neko código de bytes " o " HashLink ".
Los principales usuarios de Haxe incluyen desarrolladores de BBC , Coca-Cola , Disney , Hasbro , Mattel , Nickelodeon , Prezi , TiVo y Zynga . OpenFL (in) y Flambe son frameworks que Haxe es popular para crear contenido multiplataforma desde una sola fuente.
El aspecto más singular de la arquitectura de Haxe fue la decisión de admitir Flash , JavaScript y secuencias de comandos del lado del servidor con un lenguaje unificado. En los proyectos de desarrollo web tradicionales, los desarrolladores utilizan diferentes lenguajes para crear una aplicación web integrada.
Haxe tiene por origen sustentar todos sus aspectos en un solo idioma, y simplificar la lógica de comunicación entre ellos. Por lo tanto, la lógica de la aplicación no necesita manejar la implementación de las comunicaciones.
Los objetivos originales de Haxe son:
El compilador se divide en un front-end y varios backends . El front-end crea un árbol de sintaxis abstracta (AST) a partir del código fuente y realiza la verificación de tipos, la expansión de macros y la optimización de AST. Los diferentes backends traducen el AST así procesado en código fuente o código de bytes según su destino.
El compilador está escrito en OCaml . Se puede utilizar en modo servidor para proporcionar finalización de código para entornos de desarrollo (IDE), así como para mantener un caché para acelerar la compilación.
En Haxe, las plataformas compatibles se conocen como "objetivos". Estos son módulos de Haxe que brindan acceso a las API internas para las partes de backend del compilador que son responsables de generar el código o bytecode correspondiente.
El desarrollo de Haxe comenzó en 2005. La primera versión beta estaba disponible enFebrero de 2006. Haxe 1.0 fue lanzado el17 de mayo de 2006con soporte para objetivos Adobe Flash , JavaScript y Neko .
Haxe es el sucesor del compilador MTASC (en) de código abierto también creado por Nicolas Cannasse, y está disponible bajo la Licencia Pública General GNU . No se requiere conocimiento de OCaml para desarrollar aplicaciones usando Haxe.
El lenguaje Haxe se puede compilar en código de bytes para varias máquinas virtuales , como Adobe Flash Player y NekoVM, y generar código fuente para lenguajes como Javascript y Python .
La estrategia de compilar en múltiples lenguajes de programación está inspirada en el paradigma "escribir una vez, ejecutar en todas partes" . Esto permite al programador elegir las mejores opciones para su tarea.
Generador | Salida | Plataforma | usar | Desde |
---|---|---|---|---|
AVM1 | código de bytes | Adobe Flash Player 6+ | Escritorio, navegador | 2005 (alfa) |
AVM2 | código de bytes | Adobe Flash Player 9+, Adobe AIR , Tamarin VM | Escritorio, navegador, servidor | 2005 (alfa) |
ActionScript 3 | fuente | Adobe Flash Player 9+ | Servidor, oficina | 2007 (1,12) |
C ++ (hxcpp) | fuente | Windows , Linux , macOS | Servidor, oficina, CLI | 2009 (2,04) |
C ++ | fuente | Android , Apple iOS , Palm webOS | Móvil | 2009 (2,04) |
VS # | fuente | .NET Framework | Servidor, oficina, móvil | 2012 (2,10) |
HashLink | fuente | HashLink | Servidor, oficina | 2016 (3,3) |
Java | fuente | Java | Servidor, oficina | 2012 (2,10) |
Javascript | fuente | HTML5 , NodeJS , PhoneGap | Servidor, escritorio, navegador, móvil | 2006 (beta) |
Neko | código de bytes | NekoVM | Servidor, oficina, CLI | 2005 (alfa) |
PHP | fuente | PHP | Servidor | 2008 (2,0) |
Pitón | fuente | Pitón | CLI, web, oficina | 2014 (3,2) |
Lua | fuente | Lua | CLI, web, escritorio, móvil | 2016 (3,3) |
Haxe es un lenguaje que admite la programación orientada a objetos , la programación genérica y diversas construcciones de programación funcional . Características como iteraciones , excepciones o incluso reflexión son características básicas del lenguaje. Haxe tiene un sistema de tipos fuerte y dinámico. El compilador verificará implícitamente los tipos y dará errores de compilación. También les da a los programadores la opción de omitir la verificación de tipos y usar la escritura dinámica para la plataforma de destino.
Haxe tiene un sistema de tipos flexible y sofisticado. Los tipos disponibles son clases , interfaces, funciones, así como tipos anónimos , tipos de datos algebraicos ( enum) y tipos abstractos ( abstract). El polimorfismo parametrizado es posible para clases, funciones y tipo algebraico, lo que permite una programación genérica. La varianza en las funciones polimórficas está así apoyada.
De forma predeterminada, la escritura es estática a menos que estén presentes anotaciones de escritura dinámica , para usarse con un objetivo que lo admita. La verificación de tipos utiliza el sistema de tipos nominativos con la excepción de los tipos anónimos, donde se utiliza el sistema de tipos estructurales . Finalmente, se admite la inferencia de tipos , lo que permite declarar una variable sin anotación de tipo.
classLas clases de Haxe (palabra clave ) son similares a las de Java o ActionScript 3 . Sus campos pueden ser métodos, variables o propiedades, cada uno estático o específico para cada instancia. Soportes Haxe accessors publicy private, así como métodos más avanzados de control de acceso especificados por anotaciones. Las variables y métodos constantes estáticos pueden usar la extensión en línea con la palabra clave inline.
Las interfaces de Haxe son muy similares a las de Java, por ejemplo.
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(); }Los tipos enumerados son una parte importante del idioma; pueden parametrizarse y ser recursivos. Proporcionan soporte básico para tipos de datos algebraicos , lo que permite la inclusión de tipos de productos , similares a Haskell y ML . Se switchpueden aplicar filtros de patrones a valores enumerados, lo que permite soluciones elegantes a problemas complejos.
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)); } }Los ejemplos de tipos enumerados parametrizados están disponibles en la biblioteca estándar de Haxe, como los tipos Option y Either.
enum Option<T> { Some(v:T); None; } enum Either<L, R> { Left(v:L); Right(v:R); }Haxe también admite tipos algebraicos generalizados .
Los tipos anónimos se definen indicando explícitamente su estructura. Se pueden usar para implementar la tipificación estructural de los argumentos de la función (ver más abajo) y tener un alias con la palabra clave typedef.
typedef AliasForAnon = { a:Int, b:String, c:Float->Void };En Haxe, las funciones son objetos de primera clase . Su tipo se indica usando flechas entre los tipos de argumentos y entre los tipos de argumentos y el tipo de retorno, como está presente en muchos lenguajes de programación funcional . Sin embargo, a diferencia de Haskell y los lenguajes de la familia ML , no todas las funciones son unarias (función con un solo argumento). Por lo tanto, las firmas de los siguientes tipos tienen una semántica diferente a la de los lenguajes mencionados anteriormente. El tipo Fes una función que toma un entero ( Int) y una cadena de caracteres ( String) como argumentos y devuelve un valor de tipo real ( Float).
La misma notación en un lenguaje con solo funciones unarias se referiría a una función que toma uno como parámetro Inty devolvería una función de tipo String->Float.
Los tipos F2y F3corresponden al mismo tipo. Estas son funciones binarias que devuelven una función binaria de tipo F. Para F3, se utiliza la sintaxis para definir un tipo de función en un tipo de función.
typedef F = Int->String->Float; typedef F2 = Int->String->F; typedef F3 = Int->String->(Int->String->Float);La última incorporación al sistema de tipos de Haxe es el concepto de tipos abstractos . En Haxe, se diferencian de los tipos abstractos convencionales . Se utilizan para realizar conversiones implícitas entre diferentes tipos, lo que permite que los tipos existentes se reutilicen para fines específicos, como tipos para unidades de medida. Esto reduce en gran medida la mezcla de valores del mismo tipo pero con semántica diferente (por ejemplo, millas y kilómetros).
El siguiente ejemplo asume que el sistema métrico es el sistema predeterminado, que requiere una conversión de milla a kilómetro para los datos existentes en el formato incorrecto. Por lo tanto, este ejemplo convierte automáticamente millas en kilómetros, pero no al revés.
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 } }Como muestra el ejemplo, no se requiere una conversión explícita para realizar la asignación km = centMiles.
En muchos lenguajes de programación funcional , la escritura estructural juega un papel importante. Haxe se aplica a través de tipos anónimos, sin usar los tipos de sistema registrados de programación orientada a objetos cuando se usan los tipos nombrados. Los tipos anónimos de Haxe son análogos a las interfaces implícitas del lenguaje Go . A diferencia de las interfaces Go , es posible construir un valor a partir de un tipo anónimo.
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"}); } }También en la plataforma Haxe:
Otros lenguajes multiplataforma: