Guide de développement de guide

Qu'est-ce que fibjs?

fibjs est un framework de développement de serveurs d'applications conçu principalement pour le développement back-end web.Il est basé sur le moteur JavaScript de Google v8 et choisit une solution simultanée différente du callback traditionnel. fibjs utilise la fibre pour isoler la complexité de l'entreprise causée par les appels asynchrones au niveau de la couche cadre, ce qui réduit considérablement la difficulté de développement et réduit les problèmes de performances causés par le traitement asynchrone fréquent dans l'espace utilisateur.

Pour des raisons historiques, JavaScript est principalement utilisé pour le traitement de l'interface utilisateur du navigateur. Le développement de l'interface utilisateur est un modèle typique de type événementiel à un seul thread. Par conséquent, JavaScript a également formé un paradigme de programmation avec le traitement asynchrone comme principal paradigme de programmation.

Avec le succès de JavaScript, de plus en plus de personnes ont commencé à appliquer JavaScript à d'autres scénarios. Dans le même temps, les gens découvrent de plus en plus que le traitement asynchrone n'est pas le choix le plus approprié dans de nombreux scénarios.

Retour aux sources, développement agile

fibjs utilise la fibre dans la couche cadre pour isoler la complexité métier causée par les appels asynchrones et encapsule le traitement asynchrone d'io dans un appel synchrone plus intuitif. Les ingénieurs n'ont besoin d'écrire du code que conformément à la logique métier synchrone habituelle pour profiter des avantages du traitement asynchrone. Grande commodité.

Le code suivant est extrait de la documentation du module mysql:

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
conn.beginTransaction(err => { if (err) { throw err; } conn.query('INSERT INTO posts SET title=?', title, (error, results, fields) => { if (error) { return conn.rollback(() => { throw error; }); } var log = 'Post ' + results.insertId + ' added'; conn.query('INSERT INTO log SET data=?', log, (error, results, fields) => { if (error) { return conn.rollback(() => { throw error; }); } conn.commit((err) => { if (err) { return conn.rollback(() => { throw err; }); } console.log('success!'); }); }); }); });

Dans fibjs, pour terminer le même travail, le code est le suivant:

1 2 3 4 5 6
conn.trans(() => { var result = conn.execute('INSERT INTO posts SET title=?', title); var log = 'Post ' + results.insertId + ' added'; conn.execute('INSERT INTO log SET data=?', log); }); console.log('success!');

Si vous recherchez la simplicité, vous pouvez même écrire le code comme ceci:

1 2 3 4
conn.trans(() => conn.execute('INSERT INTO log SET data=?', 'Post ' + conn.execute('INSERT INTO posts SET title=?', title).insertId + ' added')); console.log('success!');

Nous pouvons clairement comparer les différences provoquées par deux styles de programmation différents. Moins de code entraînera moins d'erreurs. Au fur et à mesure que le code diminue, la logique du code devient plus claire. Le développement et la maintenance en bénéficieront.

Embrassez la haute énergie

Bien que nous puissions facilement augmenter la vitesse de réponse en développant le serveur, les performances devraient toujours être l'une des bases importantes pour le choix d'un cadre de développement. Avec l'introduction d'ES7, async a été introduit dans JavaScript en tant que nouveau modèle de développement asynchrone. Cependant, lorsque nous apprécions le style de synchronisation apporté par async, nous devons également faire face à son impact sur les performances.

Nous pouvons utiliser un morceau de code de test pour comparer les différences de performances induites par différents styles de programmation:

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 34 35 36 37 38 39
var count = 1000; async function test_async(n) { if (n == count) return; await test_async(n + 1); } function test_callback(n, cb) { if (n == count) return cb(); test_callback(n + 1, () => { cb(); }); } function test_sync(n) { if (n == count) return; test_sync(n + 1); } async function test() { console.time("async"); await test_async(0); console.timeEnd("async"); console.time("callback"); test_callback(0, () => { console.timeEnd("callback"); }); console.time("sync"); test_sync(0); console.timeEnd("sync"); } test();

Sous la dernière v8 v6.7.192, les résultats de ce code sont les suivants:

1 2 3
async: 5.276ms callback: 0.117ms sync: 0.038ms

Nous pouvons clairement savoir d'après les résultats des tests que lorsque l'async est largement utilisé dans le projet, le serveur passera beaucoup de temps à traiter les appels et les retours de fonction async. Nous avons également trouvé ce point dans les tests réels de certaines applications côté serveur. Et cette forte baisse des performances est totalement inacceptable.

Parce que fibjs utilise la fibre, il peut tirer pleinement parti des caractéristiques du langage JavaScript lui-même et maximiser les performances supérieures de la v8. Les ingénieurs peuvent facilement maximiser les performances du serveur.

Choix flexible de paradigme sans être kidnappé

Choisir d'utiliser fibjs ne signifie pas que vous devez utiliser un style de développement synchrone. En fait, fibjs prend en charge tout paradigme de programmation asynchrone que vous avez vu et peut basculer de manière flexible entre les styles synchrone et asynchrone.

Le rappel et l'asynchrone ont tous deux un défaut fatal, à savoir la contagion. Tant qu'une fonction est callback ou async, toutes les autres fonctions qui en dépendent doivent être callback ou async. Cela entraînera d'énormes coûts de développement dans le développement de logiciels à grande échelle.

Prenons un simple scénario de développement de serveur comme exemple. Au début du projet, nous avons choisi la mémoire comme stockage des données de session. À ce stade, nous pouvons directement lire et stocker les données en utilisant la méthode de synchronisation, et développer une entreprise complète sur cette base. Avec le développement de l'échelle commerciale, nous devons stocker les données de session dans redis ou mongodb. À ce stade, nous devons modifier les opérations liées à la session en mode asynchrone.

En théorie, nous pouvons modifier chaque fonction à son tour pour les faire répondre aux exigences des fonctions dont elles dépendent, mais cela nous oblige à bien comprendre tous les modules et avoir la capacité de les modifier. Ceci est totalement impossible lors du développement collaboratif multi-personnes ou lors de l'utilisation de modules tiers.

Par conséquent, tous les modules communs doivent fournir des interfaces de synchronisation et asynchrones pour équilibrer l'équilibre entre asynchronie et performances. Les développeurs plus ordinaires choisiront de fournir uniquement une interface asynchrone. Cela conduit à un désastre des performances.

Dans fibjs, vous pouvez facilement résoudre des problèmes similaires et éviter une infection asynchrone explicite et incontrôlée:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
var util = require('util'); function session_get(sid) { return sdata; } async function async_session_get(sid) { return sdata; } function callback_session_get(sid, cb) { cb(null, sdata); } data = session_get(sid); data = util.sync(async_session_get)(sid); data = util.sync(callback_session_get)(sid);

fibjs peut utiliser util.sync pour convertir des fonctions de rappel ou async en fonctions de synchronisation et les appeler directement. De cette façon, nous pouvons facilement intégrer des modules de différents paradigmes de programmation, et les transformer en paradigmes de synchronisation avec des coûts de développement minimes, évitant efficacement les catastrophes causées par la contagion des paradigmes.

Commencer l'expérience

Êtes-vous prêt à commencer une expérience de développement agréable? Alors, commençons par l'installation.

👉 [Environnement d' installation et d'exploitation ]