jLang : extension du ECMAScript

Version imprimable

Bonjour,
Pour répondre à mes besoins, j'ai étendu la syntaxe du Javascript pour ajouter

la syntaxe de base orientée objet
les namespaces
la réécriture des opérateurs
l'inlining de fonction

J'en ai profité pour créer un site internet (en anglais) pour partager ce programme :

http://www.jlang.org/

Je viens de le mettre en ligne il y a quelques jours. Que penses-vous de ces ajouts faits au langage ?

Voici un exemple de syntaxe :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 namespace Library.Example { private class Displayer { public inline function sayHello() { alert( 'Hello world' ); } } private var d = new Displayer(); d.sayHello(); }

Citation:
Envoyé par Spirit 203
Bonjour,
Pour répondre à mes besoins, j'ai étendu la syntaxe du Javascript pour ajouter

la syntaxe de base orientée objet
les namespaces
la réécriture des opérateurs
l'inlining de fonction

J'en ai profité pour créer un site internet (en anglais) pour partager ce programme :

http://www.jlang.org/

Je viens de le mettre en ligne il y a quelques jours. Que penses-vous de ces ajouts faits au langage ?

Voici un exemple de syntaxe :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 namespace Library.Example { private class Displayer { public inline function sayHello() { alert( 'Hello world' ); } } private var d = new Displayer(); d.sayHello(); }
Ben c'est un langage qui est une simple surcouche au JS, et après quand on doit interagir avec le DOM on écrit ça comment ?

29/10/2010, 10h09
Spirit 203

Justement, créer les specs d'une surcouche du langage javascript est trivial. En revanche, créer un transformateur l'est moins. Je ne m'amuse pas à dire "voici un nouveau langage, faites le transformateur". La justification de l'existence du site est que je met à la disposition de la communauté un transformateur de cette surcouche vers le javascript.

On peut donc écrire un script avec cette surcouche, appliquer la transformation, et exécuter le résultat dans un navigateur.
29/10/2010, 10h41
le_chomeur

je n'ai pas tout compris concernant l'implémentation direct au seins d'une page html :-/

Bonjour

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
namespace Library.Example {  
 
    private class Displayer {  
 
        public inline function sayHello() {  
            alert( 'Hello world' );  
        }  
    }  
 
    private var d = new Displayer();  
    d.sayHello();  
}

Code:

jlangc -o test.js test.jl

Code:

1
2
3
4
5
6
7
8
function b ()  
{  
}  
 
b.prototype.sayHello = function sayHello () {  
    alert("Hello world");  
};  
alert("Hello world");

Voilà le genre de chose qu'ici j'appelais "une satisfaction intellectuelle encombrante". :mouarf:

29/10/2010, 14h37
Spirit 203

Je reconnais que l'ajout de la syntaxe orientée objet n'était pas nécessaire (et d'ailleurs, ne m'a quasiment rien coûté en temps - justes quelques heures -), mais il y a d'autres fonctionnalités que je ne pense pas pouvoir qualifier de "satisfaction intellectuelle encombrante" :

http://www.jlang.org/Compatibility

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 Class = function (extend, body) { theClass = function () { if ((typeof(body) == 'undefined') && (typeof(extend) == 'object')) { for (property in extend) { this[property] = extend[property]; } } else if (typeof(body) == 'object') { if(typeof(extend) == 'function') { this.superclass = extend; this.prototype = extend; this.superclass(); delete this.superclass; } for (property in body) { this[property] = body[property]; } } if (typeof this.initilize == 'function') this.initilize(); }; return theClass; }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 classA = Class ({ name: 'truc', alert: function () { alert(this.name); }, initilize: function () { alert('init classA object'); } }); classB = Class (classA, {//class classB inherit classA... prenom: 'chose', alert: function () { alert(this.name + ' ' + this.prenom); }, initilize: function () { alert('init classB object'); } }); var A = new classA(); var B = new classB(); A.alert(); B.alert();
il y a plein de façon de faire de l'héritage et de la définition de classe en JavaScript
la programmation à objet à base de classe n'est pas obligatoirement meilleure que celle à base de prototype. et il est souvent bien plus simple d'apprendre le langage que de passer par un traducteur qui de toute façon aura des limite et ne permettra pas d'écrire aussi facilement que dans le langage d'origine.

ton jl se veux proche de C++ ou java mais il est obligatoirement différent et t'impose des limites quant à ton outils jlanc
tu as donc les limite de java comme par exemple l'impossibilité de crée des objet sans classe et les limite de ton outil certain subtilité de java ne pouvant être traduite en js

mais c'est toujours amusant de jouer avec ce genre de chose.
ça donne parfois des proches étonnantes
pour les pro de Objective-C (Langage C objet dynamique et compilé) il y a
Objective-J
Objective-J est un fichier js de 200k
la version publique en fait 24k

A+JYT