Guide de développement de guide

Qu'est-ce que les fibjs?

Fibjs est un framework de développement de serveur d'applications conçu principalement pour le développement Web, basé sur le moteur JavaScript de Google v8 et choisissant une solution de gestion de la concurrence différente de celle utilisée pour le rappel traditionnel. Fibjs utilise la fibre optique pour isoler la complexité de l'entreprise liée aux appels asynchrones dans la couche de structure, ce qui réduit considérablement les difficultés de développement et les problèmes de performances dus au traitement asynchrone fréquent de 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 mode piloté par événement à un seul thread, de sorte que JavaScript constitue également une programmation asynchrone en tant que paradigme de programmation principal.

Avec le succès de JavaScript, de plus en plus de personnes commencent à appliquer JavaScript à d'autres scénarios. Parallèlement, les utilisateurs constatent de plus en plus que le traitement asynchrone n’est pas le choix le plus approprié dans de nombreux scénarios.

Retour au développement original et agile

Fibjs utilise la fibre dans la couche d'infrastructure pour isoler la complexité de l'entreprise induite par les appels asynchrones et encapsule le traitement asynchrone de io en appels synchrones plus intuitifs.Les ingénieurs n'ont besoin que d'écrire du code conformément à la logique métier synchrone habituelle, qui peut être utilisée par le traitement asynchrone. Grande commodité.

Le code suivant provient 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, faites la même chose, 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 entre les deux styles de programmation. Moins de code entraîne moins d'erreurs et plus le code est réduit, plus la logique du code est claire, et à la fois le développement et la maintenance en bénéficient.

Embrasser haute énergie

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

Nous pouvons utiliser un morceau de code de test pour comparer les différences de performances entre 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, le résultat de ce code est le suivant:

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

Les résultats des tests montrent clairement que, lorsque le protocole asynchrone est largement utilisé dans un projet, le serveur passe beaucoup de temps à traiter l'appel et à renvoyer la fonction asynchrone. Nous l'avons également constaté lors des tests de certaines applications serveur. Et cette forte baisse de performance est totalement inacceptable.

Fibjs utilise la fibre pour tirer pleinement parti des fonctionnalités du langage JavaScript et optimiser les performances de la v8. Les ingénieurs peuvent facilement optimiser les performances de leurs serveurs.

Choix flexible de paradigme sans être kidnappé

Le choix d'utiliser fibjs ne signifie pas que vous devez utiliser un style de développement synchrone: en fait, fibjs prend en charge tous les paradigmes de programmation asynchrones que vous avez vus et vous offre la possibilité de basculer entre les styles synchrone et asynchrone.

Qu'il s'agisse d'un rappel ou asynchrone, il existe un défaut fatal, qui est contagieux. Tant qu'une fonction est callback ou async, toutes les autres fonctions qui en dépendent doivent être callback ou async. Cela entraînera des coûts de développement énormes dans le développement de logiciels à grande échelle.

Prenons un scénario simple de développement de serveur. Au début du projet, nous avons choisi la mémoire en tant que magasin de données de session, à ce stade, nous pouvons utiliser la méthode sync pour lire et stocker les données directement, ce qui nous permet de développer une activité complète. Au fur et à mesure que l'entreprise grandit, nous devons stocker les données de session dans redis ou mongodb, puis modifier les opérations liées à la session en mode asynchrone.

En théorie, nous pouvons modifier chaque fonction à son tour pour répondre aux exigences de la fonction dont elle dépend, mais cela nous oblige à comprendre parfaitement tous les modules et à les modifier. Cela est totalement impossible lors d'un développement collaboratif à plusieurs personnes ou lors de l'utilisation de modules tiers.

Par conséquent, tous les modules communs doivent fournir des interfaces sync et async pour équilibrer l’équilibre entre asynchrone et performance. Les développeurs plus normaux choisiront de ne fournir que l'interface asynchrone. Cela provoque un désastre de performances.

Dans fibjs, vous pouvez facilement résoudre des problèmes similaires et éviter les infections non contrôlées asynchrones explicites:

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 transformer une fonction de rappel ou async en une fonction de synchronisation et l'appeler directement. De cette manière, nous pouvons facilement intégrer des modules de différents paradigmes de programmation et les transformer en paradigmes de synchronisation avec un coût de développement minimal, évitant ainsi efficacement la catastrophe causée par une infection de paradigme.

Commencer l'expérience

Prêt à commencer une expérience de développement agréable? Commençons par l’installation.

👉 [Environnement d' installation et d'exploitation ]