[Article] Découvrez le yielded style programming ou développement JavaScript asynchrone linéaire

Version imprimable

Voir 40 message(s) de cette discussion en une page

16/08/2013, 13h12
Lcf.vs

Nouvelle version!

Suite à une confusion entre les générateurs JS 1.7 présentés par MDN et ceux proposés pour l'ES6, j'ai fait une nouvelle version basée sur la future norme, puisque les autres ne sont/seront pas standards.

Attention, pour le moment, elle n'est compatible qu'avec Node.js en version >= 0.11.x, avec l'option --harmony

Vous noterez l'astérisque après le mot function, pour les fonctions retournant un générateur, ainsi que le changement de nom de méthode (next, au lieu de send), afin de se conformer à l'évolution des générateurs.

Nouvelle version (majeure) : 1.1.0

La communication parent <-> enfant a été simplifiée.

Fonctionnement actuel :

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
25
26
27
28
29
30
31
32
33
var fct, fctBis, yielded;
 
fct = function* fct(value) {
    var response, yieldedChild, child;
 
    response = value;
 
    yieldedChild = this.yld(fctBis); // ylds fctBis with this context as parent
 
    yield child = yieldedChild(); // stores the child scope
 
 
    while (response !== 5) {
        response = yield setTimeout(function () {
            console.log(response);
            child.next(response); // sends the new value to the next child context yield
        }, 2000);
    }
};
 
fctBis = function* fctBis() {
    var parent, response;
 
    parent = this.parent;
 
    while (true) {
        response = yield parent.next(response + 1); // sends the response to the parent context
    }
};
 
yielded = yld(fct);
 
yielded(1);

Le diff

EDIT :

Nouvelle version : 1.1.1

Le setter this.error devient this.throw(), conformément aux générateurs ES6

19/08/2013, 13h43
Kaamo

Je m'étais penché sur la question il y a quelques temps suite à la découverte de TaskJS. Connais - tu ? (c'est périmé, c'est sorti y'a deux ans quand Firefox a fourni les générateurs). Je suis plutôt "enjoué" de ce nouveau style qui va prendre le dessus, je pense, quand le prochain ES sera bien déployé dans le paysage.

Personnellement j'utilise de plus en plus les promises (un équivalent maison de "Q") en attendant que l'implémentation/l'utilisation des générateurs/coroutines mûrisse.

Quoiqu'il en soit, je testerai ta librairie pour faire un retour plus copieux :)
19/08/2013, 13h50
Lcf.vs

Citation:

Envoyé par Kaamo

Je m'étais penché sur la question il y a quelques temps suite à la découverte de TaskJS. Connais - tu ? (c'est périmé, c'est sorti y'a deux ans quand Firefox a fourni les générateurs). Je suis plutôt "enjoué" de ce nouveau style qui va prendre le dessus, je pense, quand le prochain ES sera bien déployé dans le paysage.

Personnellement j'utilise de plus en plus les promises (un équivalent maison de "Q") en attendant que l'implémentation/l'utilisation des générateurs/coroutines mûrisse. :)

Me spécialisant en full natif, non, je ne connais ces outils que de nom.

Je ne sais pas si mon outil deviendra vraiment populaire, une fois standardisé, néanmoins, oui, je pense aussi que le développement JS de demain sera majoritairement basé sur les générateurs.

Citation:

Envoyé par Kaamo

Quoiqu'il en soit, je testerai ta librairie pour faire un retour plus copieux

Quand tu veux, même si ce n'est pas positif, n'hésite pas.

(PS: jusqu'ici, les rares personnes qui l'ont testé ont l'air d'apprécier :))

Un simple petit goto asynchrone :

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
25
26
27
28
29
30
31
32
33
var goto;
 
goto = function* () {
    var response;
 
    while (!(response instanceof Error)) {
        switch (response) {
            case undefined:
                console.log('started');
                response = yield this.next('label_0');
            break;
 
            case 'label_0':
                console.log('label_0');
                response = yield this.next('label_2');
            break;
 
            case 'label_1':
                console.log('label_1');
                response = yield this.next(new Error());
            break;
 
            case 'label_2':
                console.log('label_2');
                response = yield this.next('label_1');
            break;
        }
    }
 
    yield this.throw(response);
};
 
yld(goto)();

20/08/2013, 17h25
Lcf.vs
Sans Node.js, il vous est aussi possible de tester yld via Chrome canary, en activant les fonctionnalités JavaScript expérimentales.
- Installez Chrome canary
- Rendez-vous à l'url about:flags
- Activer la fonctionnalité expérimentale JavaScript (quasi tout en bas)
- Redémarrez Chrome canary
- Enjoy ;)
30/08/2013, 10h30
Lcf.vs

Quelqu'un a-t-il pu tester mes exemples? (ceux sur GitHub)

Un petit feedback? :)
30/08/2013, 11h17
Kaamo

Pas encore :|
Mais c'est prévu ! Ça fait parti d'une étude que je dois réaliser sur les différences entre Callbacks/Promises/Générateur-coroutines. Il y a tellement à dire et à apprendre sur le sujet !
D'ailleurs, les Promises débarquent sur Chrome en natif, de la concurrence pour toi :mrgreen:
30/08/2013, 11h26
Lcf.vs

En effet, plusieurs solutions existent, je ne fais qu'en proposer une parmi tant d'autres, je pense notamment à celles basées sur Fibers (Node.js). ;)

C'est juste plus compliqué que ce que je pensais, de faire connaître un outil... bien que je sois conscient que comme c'est encore de l'expérimental, certains ont peut-être peur de perdre leur temps.
30/08/2013, 12h12
Kaamo

C'est clair que cette techno est encore une "niche" dans le sens où on ne peut pas l'utiliser d'office dans le navigateur.
Mais ça va évoluer, c'est sûr et quand ça sera mûr, y'a de forte chance que tout le monde se dirige vers des lib comme la tienne
30/08/2013, 13h12
Lcf.vs

Perso, j'espère assez vite un support des destructuring assignments, dans V8... que je puisse illustrer mon exemple de lecture de fichier, de manière plus élégante. :P
30/08/2013, 13h38
Kaamo

Par contre Firefox a ça non ?
Chrome pas encore.
Sais tu s'il y a une sorte de "roadmap" pour V8 ?
30/08/2013, 13h51
Lcf.vs

Firefox le supporte, oui. ;)

Par contre, concernant une roadmap de V8, je ne pense pas qu'ils en aient publié... Ils ont plutôt l'air de bosser dans le plus grand secret... :?

Perso, je suis son évolution via le Google Group (dev)
13/09/2013, 11h17
Lcf.vs
Nouvelle version majeure (v 1.2.0)

Permet de définir un délai pour chaque appel à generator.next() ou generator.nextCb().
Code:

1 2 generator.next.bind(delay); generator.nextCb.bind(delay);
24/12/2013, 13h58
Lcf.vs

Pour ceux que cela intéresse, les futurs générateurs ES6 sont désormais compatibles avec Firefox (version >= 27). ;)

Et joyeux Noël à tous. :)

Voir 40 message(s) de cette discussion en une page