JS++

Dado que JS++ es un superconjunto de JavaScript, declarar los tipos de datos para las variables es opcional. Sin embargo, cuando se declaran los tipos, estos se aplican tanto en tiempo de compilación como en tiempo de ejecución.

Las anotaciones de tipo en JS++ utilizan la sintaxis tradicional de C / C++ :

int x = 1 ; var y = 2 ; bool z = true ;

Cabe destacar que esto difiere de TypeScript y ActionScript , que utilizan un estilo más detallado:

var x : número = 1 ; var y : cualquiera = 2 ; var z : booleano = verdadero ;

El sistema de tipos en JS++ es sólido para los casos límite de ECMAScript y la API DOM , incluidos los objetos host, los pares clave-valor dinámicos, Comet , la compilación condicional de JScript , los tipos de retorno dinámicos, ActiveX , ECMAScript para XML , el recolector de basura del navegador web y los errores de conteo de referencias cíclicas , la lógica condicional y otros casos límite y extremos . ^{[ 9 ] [ 10 ]} Esto difiere de otros superconjuntos de JavaScript donde los tipos son opcionales y se descartan en tiempo de ejecución mediante el borrado de tipos , como en TypeScript . ^{[ 11 ] [ 12 ]}

JS++ puede usar bibliotecas de JavaScript mediante una instrucción de una sola línea, externalcomo en el siguiente ejemplo de la página principal de JS++:

import System ; // Importa las bibliotecas de JavaScript en una línea de código external jQuery , $ ;clase Example { public Example () { // Casi ninguna curva de aprendizaje // Puedes seguir escribiendo JavaScript normal var a = 0 , random = Math . random (); // Tipos enteros y otros tipos primitivos // ... permiten un código rápido (optimizado) y claro byte [] rgbColors = [ 0xFF , 0xFA , 0xFF ]; }public void showMessage ( int id , string text ) { // 100% compatible con JavaScript estándar jQuery ( "#msgbox" ). show (); $ ( " # msgbox" ). text ( id.toString ( ) + text ); } }

Si bien las clases en JavaScript ( ECMAScript 6 ) son azúcar sintáctico para prototipos internamente, ^{[ 13 ]} las clases de JS++ se asemejan a las clases que se encuentran en lenguajes de programación clásicos como C++ , Java y C# en términos de disposición de memoria, rendimiento y semántica. Las "clases" son un concepto estático y no se pueden alterar en tiempo de ejecución (durante la ejecución del programa) como es el caso de JavaScript , Smalltalk , Lisp y TypeScript , que dependen de prototipos. ^{[ 14 ]} Por ejemplo, los métodos privados son privados tanto en tiempo de compilación como en tiempo de ejecución, y los objetos JavaScript externos no pueden acceder a campos o métodos privados de JS++, incluso si se obtiene una referencia a un objeto JS++ desde JavaScript.

import System ; class Employee : IComparable <Employee> { private string firstName ; private string lastName ; public Employee ( string firstName , string lastName ) { this.firstName = firstName ; this.lastName = lastName ; } public override Comparison compare ( Employee that ) { // Ordenar por apellido del empleado return this.lastName.compare ( that.lastName ) ; } public override string toString ( ) { return this.firstName + " " + this.lastName ; } }​​​​​​​​Empleado zig = nuevo empleado ( "Zig" , "Ziglar" ); Empleado john = nuevo empleado ( "John" , "Smith" ); Empleado abe = nuevo empleado ( "Abe" , "Lincoln" );Empleado [] empleados = [ zig , john , abe ] ; empleados.sort ( ) ; Console.log ( empleados.join ( " , " )) ;

Abraham Lincoln, John Smith, Zig Ziglar

devolver this.lastName.compare ( that.lastName ) ;​​​​​

empleados.ordenar ( ) ;

Console.log ( employees.join ( " , " ) ) ;

clase Punto { int x , y ; Punto ( int x , int y ) { this . x = x ; this . y = y ; } int obtenerX () { return this . x ; }int obtenerY () { return this . y ; } }

Un acceso fuera de los límites suele ocurrir con matrices y otros contenedores. Por ejemplo, cuando accedemos al elemento número 100 de una matriz de 3 elementos, se produce un acceso fuera de los límites:

int [] arr = [ 1 , 2 , 3 ] ; Console.log ( arr [ 100 ] ); // Acceso fuera de límites, 'arr' no tiene un elemento en el índice 100

En Java y C# , esto puede provocar una excepción y la terminación del programa. En C , puede provocar desbordamientos de búfer o fallos de segmentación . C++ presenta semántica variable, como inicialización por defecto, excepciones, fallos de segmentación o desbordamientos de búfer. ^{[ 17 ] [ 18 ]}

JS++ puede analizar y prevenir eficientemente errores fuera de límites en tiempo de compilación . ^{[ 19 ] [ 20 ] [ 21 ]}

JavaScript tiene la noción de valores nullvacíos y undefinedvacíos, donde nullsignifica que hay un valor presente pero es un valor vacío, y undefinedsignifica que no hay ningún valor allí. JS++ extiende esta intuición aún más para diferenciar entre valores vacíos y accesos fuera de límites. ^{[ 21 ]}

Considere el siguiente código, con un inttipo anulable representado con int?:

int [] a = [ 1 , 2 ] ; int ? value1 = a [ 2 ]; if ( value1 == null ) { Console.log ( "Definitivamente fuera de rango" ); } int ? [] b = [ 1 , null ]; int ? value2 = b [ 2 ]; if ( value2 == null ) { Console.log ( " Podría estar fuera de rango, podría ser simplemente un acceso a un elemento nulo " ) ; }

Si bien los tipos anulables pueden representar un acceso fuera de los límites, este concepto falla cuando el array puede contener valores anulables, como se ilustra arriba. En cambio, JS++ introduce un concepto adicional además de los valores nulos: los valores indefinidos. Recordemos que JS++ extiende la noción de JavaScript de que nulo significa que un valor está presente pero es un valor vacío, mientras que un valor indefinido significa que un valor no existe en absoluto. JS++ utiliza el concepto de "un valor no existe en absoluto" para indicar que se ha producido un acceso fuera de los límites, y este concepto se conoce en JS++ como "tipos existentes". ^{[ 21 ]}

Por lo tanto, el ejemplo anterior puede modificarse. El tipo existente int+significa " into fuera de límites" y int?+significa " int, null, o fuera de límites":

int [] a = [ 1 , 2 ] ; int ? valor1 = a [ 2 ]; if ( valor1 == undefined ) { Console.log ( " Definitivamente fuera de los límites" ); }int ? [] b = [ 1 , null ]; int ?+ value2 = b [ 2 ]; if ( value2 == undefined ) { Console . log ( "Definitivamente fuera de límites" ); }

Intuitivamente, esto significa que los tipos existentes no pueden usarse como tipo subyacente para los elementos de un array. JS++ impone esta restricción en tiempo de compilación:

int + [] arr = []; // ERROR

[ ERROR ] JSPPE5204: El tipo existente `int+' no se puede utilizar como tipo de elemento para matrices

En lugar de seguir cada rama condicional o ruta de llamada a método virtual, lo que resultaría en una explosión de rutas y tiempos de compilación exponenciales, los tipos existentes tienen esencialmente el mismo costo de análisis en tiempo de compilación que int, bool, y otros tipos primitivos . En consecuencia, se ha demostrado que los tiempos de compilación no se ven afectados (±1-2 ms) por la introducción de tipos existentes. ^{[ 21 ]} Dado que los tipos existentes se utilizan para todos los tipos de matrices y contenedores en JS++ (como mapas hash , , y ), los contenedores de JS++ tienen garantizado que no tendrán errores fuera de límites.Stack<T>Queue<T>

En JS++, undefinedes un valor que no se puede cambiar. En JavaScript ( ECMAScript 3 ), undefinedes una propiedad mutable del objeto global, lo que da lugar a circunstancias en las que "undefined" puede ser "defined". ^{[ 22 ]} Por lo tanto, los tipos existentes no habrían sido posibles en JavaScript puro, ya que los arrays pueden contener elementos con el valor undefined, undefined puede ser definido, u otros casos límite y extremos que se evitan en JS++. ^{[ 21 ] [ 23 ]}

Además, en comparación con Java y los primeros lenguajes orientados a objetos como Eiffel , ^{[ 24 ] [ 25 ]} JS++ no inicializa los objetos por defecto a null. ^{[ 21 ]} En cambio, el compilador impone la inicialización por parte del programador:

clase Coche {}Coche coche ;

[ERROR] JSPPE6000: La variable `car' no está inicializada en la línea 3, carácter 4

Por lo tanto, dado que los tipos existentes están profundamente integrados en el lenguaje, JS++ puede garantizar que nunca se produzcan errores de acceso fuera de límites. ^{[ 26 ] [ 10 ]}

JS++ proporciona tipos de enteros de 8, 16, 32 y 64 bits, así como tipos de punto flotante :

byte b1 = 0xFF ; // byte sin signo de 8 bits byte con signo b2 = -1 ; // byte corto con signo de 8 bits s1 = 1 ; // byte corto sin signo de 16 bits sin signo s2 = 1 ; // byte entero sin signo de 16 bits int x1 = 0 ; // byte entero sin signo de 32 bits sin signo x2 = 0 ; // byte largo sin signo de 32 bits z1 = 1 ; // byte largo sin signo de 64 bits sin signo z2 = 1 ; // byte largo sin signo de 64 bitsfloat f = 0.5 ; // punto flotante de precisión simple double d = 0.5 ; // punto flotante de doble precisión

Desde la página principal del proyecto:

// No es necesario declarar el tipo de una variable y puedes // seguir escribiendo JavaScript normal (de nuevo, SIN curva de aprendizaje): var offset = 0 ;// Pero, si lo haces, esta siguiente variable siempre seguirá siendo un 'unsigned int', incluso en tiempo de ejecución. // Nunca volverás a ver errores de tiempo de ejecución NaN ("No es un número"). // Esta variable es 'unsigned', por lo que también se garantiza que nunca será negativa. unsigned int pageHeight = $ ( document ). height ();

Todas las variables en JS++ tienen ámbito de bloque, incluida la varinstrucción JavaScript. ^{[ 29 ] [ 30 ] [ 31 ]} Por lo tanto, no hay necesidad de dos palabras clave de declaración de variables diferentes con reglas de ámbito diferentes, como vary letcoexistiendo simultáneamente en JavaScript ( ECMAScript 6 ).

El compilador JS++ está disponible para Windows , macOS y Linux . Es un compilador de código fuente a código fuente que genera código fuente JavaScript como una representación intermedia .

El compilador está desarrollado con C / C++ y los desarrolladores afirman que hay "menos de 10 informes de errores abiertos en el compilador principal" después de 3,5 años de ingeniería y 400.000 líneas de código. ^{[ 31 ] [ 32 ]}

JS++ se integra con varios editores de código, incluidos Visual Studio Code , Atom y Sublime Text . ^{[ 33 ] [ 34 ] [ 35 ]}

JS++ se puede integrar con herramientas de compilación de terceros como Webpack . ^{[ 36 ]}