Haxe

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
Haxe
Desarrollador(es)
Nicolas Cannasse
haxe.org
Información general
Extensiones comunes .hx
Paradigma Multiparadigma
Apareció en 2005
Última versión estable 2.10 (16 de julio de 2012; hace 1 año (2012-07-16))
Tipo de dato Estático
Influido por

ActionScript,

OCaml
Sistema operativo Multiplataforma
Licencia BSD

Haxe es un lenguaje de programación multiplataforma de alto nivel y de código abierto, y compilador que puede producir programas y código fuente para distintas plataformas desde un único código base. El código escrito en Haxe puede ser compilado en aplicaciones en Adobe Flash, programas Javascript, y en cierta medida de aplicaciones independientes en C++, y en aplicaciones de lado del servidor en PHP, Apache CGI y Node.js.

Haxe incluye un conjunto de funcionalidades comunes que son compatibles con todas las plataformas, como tipos de datos numéricos, texto, arrays, binarios y otros formatos de archivos comunes. Haxe también incluye APIs exclusivas de las plataformas, pero a partir de 2012, sólo admite un subconjunto de las funciones disponibles en cada plataforma, y solo la API de Flash es totalmente utilizable. Haxe también puede compilar en código Neko, que se ejecuta en el tiempo de ejecución de Neko creado por el mismo desarrollador.

Haxe fue desarrollado por Nicolas Cannasse y otros colaboradores, y fue llamado Haxe porque era corto, simple, y con una X dentro, que el autor afirma con humor que es necesario para que una nueva tecnología tenga éxito. Haxe se pronuncia "hex" (/heks/) aunque los autores de un libro publicado lo pronuncian "hacks".

Arquitectura[editar]

El desarrollo de Haxe empezó en Octubre de 2005 y la primera versión beta salió en Febrero de 2006. Haxe 1.0 salió en Abril de 2006, que soporta aplicaciones de Adobe Flash.

Haxe es el sucesor de código abierto de ActionScript 2 compilador MTASC, también creado por Nicolas Canesse, y está liberado bajo Licencia Pública General de GNU versión 2. Haxe tiene mucho en común con ActionScript 3. El compilador de Haxe está desarrollado en el lenguaje OCaml. No es necesario saber OCaml para desarrollar aplicaciones en Haxe.

El compilador de Haxe es un compilador optimizado, y contiene las siguientes características de optimización:

  • Funciones de expansión en línea
  • Plegado constante
  • Eliminación de código muerto

El rendimiento de apliaciones desarrolladas en Haxe depende de la plataforma destinada,y en el caso de ActionScript 3, programas producidos usando el compilador de Haxe normalmente funcionan más rápidos que programas producidos usando el compilador Adobe Flex SDK.

Para ayudar a aprovechar código existente, la comunidad de código libre ha creado conversores de código fuente experimentales para los siguiente lenguajes:

  • ActionScript 3 a Haxe.
  • C# a Haxe.

La ventajas de usar Haxe incluyen:

  • Independencia de la plataforma
  • Un lenguaje de alto nivel totalmente desarrollado
  • Dispositivos que admiten solo C++

Soporte de la plataforma[editar]

El código Haxe puede ser compilado en bytecode para maquinas virtuales diferentes como las de Adobe Flash Player y Neko, y puede generar código fuente para ActionScript 3, JavaScript, e incluye soporte experimental para C++ y C#. Esta estrategia de compilar a múltiples códigos fuente de distintos lenguajes está inspirada por el paradigma escribe una vez, ejecuta en todas partes. Esto también permite al programador elegir el mejor compilador para su trabajo.

Soporte total[editar]

Hasta 2012, Haxe pueden compilar en las siguientes plataformas con la API de la plataforma completa:

Soporte parcial[editar]

Hasta 2012, Haxe pueden compilar en las siguientes plataformas con cierta parte de la API de la plataforma:

  • C++
    • Windows
    • Linux
    • Mac OSX
    • iOS, (experimental)
    • Android, (experimental)
    • webOS, (experimental)
  • Java (experimental)
  • C# (experimental)

Lenguaje[editar]

El lenguaje Haxe es similar a ECMAScript, aunque casi ningún código ECMAScript se ejecutará en Haxe sin modificaciones. A diferencia de ECMAScript, Haxe es un lenguaje compilado. Es un lenguaje de propósito general con programación orientada a objetos, excepciones, e inferencia de tipos con parámetros de clase. Clases genéricas, reflectividad, iteradores, y programación funcional están incorporados en la funcionalidad del lenguaje y librerías. A diferencia de otros lenguajes de programación, Haxe contiene un sistema de tipos fuerte y dinámico. El compilador comprobará tipos implícitos y dará errores de compilación, pero eso también permite al programador omitir la comprobación de tipos y se basan en el manejo dinámico de tipos de la plataforma de destino.

Desde que Haxe tiene sus orígenes en AS3, todas las APIs de Flash pueden ser usadas, aunque Haxe requiere código mejor formado y estándares de programación a diferencia de los compiladores Adobe (por ejemplo, respecto al ámbito y tipo de dato).

Los parámetros de las funciones pueden ser definidos de forma muy precisa en Haxe:

function multipleparams (threedimensionalarray : Array<Array<Array<Int>>>, stringval : String, boolval : Bool) {
}
// Valor entero opcional devuelve un entero
function optionalargument ( ?i : Int ) : Int {
    return 0;
}
// Llama a una función sin parámetros
function functionasparameter ( f : Void -> Void ) {
    f();
}
// Llama a una función que retorna un entero, con un parámetro Int
function anotherfunctionparm ( f : Int -> Int ) {
    var result = f(1);
}
// función que coge cualquier clase de tipo y lo devuelve
function icoulddoanything (d : Dynamic) : Dynamic {
    return d;
}

Tipos enumerados son una característica clave del lenguaje; pueden tener parámetros propios y ser recursivos. Son similares a los tipos de datos algebraicos en lenguajes como ML o Haskell. Las enumeraciones en Haxe no son simplemente indexados valores de "número mágico" como en la mayoría de los lenguajes, pero es más abstracto: no contienen ningún valor inherente, pero pueden ser instanciados en variables como en este ejemplo:

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

Este ejemlo dibuja un cuadrado rojo usando el objeto Flash MovieClip, y usa la palabra clave "using".

using Colors;
class Test {
  static function main() {
    var mc: flash.display.MovieClip = flash.Lib.current;
    mc.graphics.beginFill(red.toInt());
    mc.graphics.moveTo(50,50);
    mc.graphics.lineTo(100,50);
    mc.graphics.lineTo(100,100);
    mc.graphics.lineTo(50,100);
    mc.graphics.endFill();
  }
}

Véase también[editar]

Lenguajes similares que compilan a JavaScript:

Lenguajes multiplataforma similares:

Enlaces externos[editar]