Guida Guida allo sviluppo

Che cos'è fibjs?

fibjs è un framework di sviluppo di application server progettato principalmente per lo sviluppo di back-end Web. È basato sul motore JavaScript di Google v8 e sceglie una soluzione di concorrenza diversa rispetto al callback tradizionale. Fibjs utilizza la fibra per isolare la complessità aziendale causata da chiamate asincrone a livello di framework, il che riduce notevolmente la difficoltà di sviluppo e riduce i problemi di prestazioni causati dalla frequente elaborazione asincrona nello spazio utente.

Per motivi storici, JavaScript viene utilizzato principalmente per l'elaborazione dell'interfaccia utente nei browser e lo sviluppo dell'interfaccia utente è un tipico modello basato su eventi a thread singolo, pertanto JavaScript ha anche formato un'elaborazione asincrona come principale paradigma di programmazione.

Con il successo di JavaScript, sempre più persone hanno iniziato ad applicare JavaScript ad altri scenari. Allo stesso tempo, le persone stanno scoprendo sempre più che l'elaborazione asincrona non è l'opzione più appropriata in molti scenari.

Torna allo sviluppo originale e agile

Fibjs utilizza la fibra a livello di framework per isolare la complessità aziendale causata dalle chiamate asincrone e incapsula l'elaborazione asincrona di io in chiamate sincrone più intuitive. Gli ingegneri devono solo scrivere codice secondo la consueta logica aziendale sincrona per godere dei vantaggi dell'elaborazione asincrona. Grande comodità.

Il seguente codice è tratto dalla documentazione del modulo 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!'); }); }); }); });

In fibjs, per completare lo stesso lavoro, il codice è il seguente:

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!');

Se persegui la semplicità, puoi persino scrivere codice in questo modo:

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!');

Possiamo confrontare chiaramente le differenze apportate da due diversi stili di programmazione. Meno codice porterà meno errori e, man mano che il codice diminuisce, la logica del codice diventa più chiara, che si tratti di sviluppo o manutenzione, ne trarrà beneficio.

Abbraccia l'alta energia

Sebbene possiamo facilmente aumentare la velocità di risposta espandendo il server, le prestazioni dovrebbero comunque essere una delle basi importanti per la scelta di un framework di sviluppo. Con l'introduzione di ES7, async è stato introdotto in JavaScript come nuovo modello di sviluppo asincrono. Tuttavia, quando ci piace lo stile di sincronizzazione portato da asincrono, dobbiamo anche affrontare il suo impatto sulle prestazioni.

Possiamo usare un pezzo di codice di prova per confrontare le differenze di prestazioni apportate da diversi stili di programmazione:

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();

Nell'ultima versione v8 v6.7.192, i risultati di questa esecuzione del codice sono i seguenti:

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

Dai risultati del test possiamo chiaramente sapere che quando l'asincrono è ampiamente utilizzato nel progetto, il server impiegherà molto tempo per elaborare la chiamata e restituire la funzione asincrona. Abbiamo anche trovato questo nel test effettivo di alcune applicazioni server. E questo forte calo delle prestazioni è completamente inaccettabile.

Poiché fibjs utilizza la fibra, può sfruttare appieno le caratteristiche del linguaggio JavaScript stesso e massimizzare le prestazioni superiori di v8. Gli ingegneri possono facilmente massimizzare le prestazioni del server.

Scelta flessibile del paradigma senza essere rapito

Scegliere di utilizzare fibjs non significa che è necessario utilizzare uno stile di sviluppo sincrono, in realtà fibjs supporta qualsiasi paradigma di programmazione asincrono che si è visto e può passare in modo flessibile dallo stile sincrono a quello asincrono.

Che si tratti di callback o asincrono, c'è un difetto fatale, che è contagioso. Finché una funzione è callback o asincrona, tutte le altre funzioni che dipendono da essa devono essere callback o asincrone. Ciò comporterà enormi costi di sviluppo nello sviluppo di software su larga scala.

Prendi un semplice scenario di sviluppo del server come esempio. Nella fase iniziale del progetto, abbiamo scelto la memoria come archivio di dati della sessione. Al momento, possiamo utilizzare la sincronizzazione per leggere e archiviare i dati direttamente e sviluppare un business completo basato su questo. Con lo sviluppo della scala aziendale, è necessario archiviare i dati della sessione in redis o mongodb. Al momento, è necessario modificare le operazioni relative alla sessione in modalità asincrona.

In teoria, possiamo modificare ciascuna funzione a turno per renderle conformi ai requisiti della funzione da cui dipende, ma ciò richiede che comprendiamo appieno tutti i moduli e che siano in grado di modificarli. Ciò è del tutto impossibile quando si sviluppa lo sviluppo collaborativo di più persone o quando si utilizzano moduli di terze parti.

Pertanto, tutti i moduli comuni devono fornire interfacce sia sincrone che asincrone per bilanciare l'equilibrio tra asincrono e prestazioni. Gli sviluppatori più ordinari sceglieranno di fornire solo un'interfaccia asincrona. In tal modo causando disastri alle prestazioni.

In fibjs, puoi facilmente risolvere problemi simili ed evitare infezioni asincrone e incontrollate esplicite:

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 può utilizzare util.sync per trasformare le funzioni di callback o asincrono in funzioni di sincronizzazione e chiamarle direttamente. In questo modo, possiamo facilmente integrare moduli di diversi paradigmi di programmazione e trasformarli in paradigmi di sincronizzazione a un costo di sviluppo minimo, evitando efficacemente il disastro causato dal contagio del paradigma.

Inizia a provare

Sei pronto per iniziare una piacevole esperienza di sviluppo? Quindi, inizia con l'installazione.

👉 【 Ambiente operativo e di installazione