Guida allo sviluppo della guida

Cos'è fibjs?

fibjs è un framework per lo sviluppo di server applicativi progettato principalmente per lo sviluppo back-end Web. Si basa sul motore JavaScript di Google v8 e sceglie una soluzione simultanea diversa dai callback tradizionali. fibjs utilizza la fibra per isolare la complessità aziendale causata dalle chiamate asincrone a livello del framework, il che riduce notevolmente la difficoltà di sviluppo e riduce i problemi di prestazioni causati dalla frequente elaborazione asincrona nello spazio utente.

Per ragioni storiche, JavaScript viene utilizzato principalmente per l'elaborazione dell'interfaccia utente del browser. Lo sviluppo dell'interfaccia utente è un tipico modello basato su eventi a thread singolo. Pertanto, JavaScript ha anche formato un paradigma di programmazione con elaborazione asincrona come paradigma di programmazione principale.

Con il successo di JavaScript, sempre più persone iniziano ad applicare JavaScript ad altri scenari. Allo stesso tempo, le persone stanno scoprendo sempre più che l'elaborazione asincrona non è la scelta più adatta in molti scenari.

Ritorno alle basi, sviluppo agile

fibjs utilizza la fibra nel livello del framework per isolare la complessità aziendale causata dalle chiamate asincrone e incapsula l'elaborazione asincrona di io in una chiamata sincrona più intuitiva. Gli ingegneri devono solo scrivere codice in conformità con la consueta logica di business sincrona per godere dei vantaggi dell'elaborazione asincrona. Grande comodità.

Il codice seguente è 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 il 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 chiaramente confrontare le differenze determinate da due diversi stili di programmazione. Meno codice porterà meno errori. Man mano che il codice diminuisce, la logica del codice è più chiara e ne trarranno vantaggio sia lo sviluppo che la manutenzione.

Abbraccia l'alta energia

Sebbene sia possibile aumentare facilmente 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 offerto da async, dobbiamo anche affrontare il suo impatto sulle prestazioni.

Possiamo usare un pezzo di codice di test per confrontare le differenze di prestazioni causate 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 v8 v6.7.192, i risultati di questo codice sono i seguenti:

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

Possiamo chiaramente sapere dai risultati del test che quando async è ampiamente utilizzato nel progetto, il server impiegherà molto tempo a elaborare chiamate e restituzioni di funzioni async. Abbiamo riscontrato questo problema anche in alcuni test effettivi delle applicazioni lato server. E questo forte calo delle prestazioni è totalmente inaccettabile.

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

Scelta flessibile del paradigma senza essere rapiti

Scegliere di usare fibjs non significa che devi usare uno stile di sviluppo sincrono, infatti fibjs supporta qualsiasi paradigma di programmazione asincrona che hai visto e può passare in modo flessibile tra stili sincroni e asincroni.

Sia il callback che l'async hanno un difetto fatale, cioè il contagio. 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. All'inizio del progetto, abbiamo scelto la memoria come archiviazione dei dati della sessione. A questo punto, possiamo utilizzare il metodo di sincronizzazione per leggere e archiviare direttamente i dati e sviluppare un'attività completa basata su questo. Con lo sviluppo della scala aziendale, dobbiamo memorizzare i dati della sessione in redis o mongodb. In questo momento, dobbiamo modificare le operazioni relative alla sessione in modalità asincrona.

In teoria, possiamo modificare ciascuna funzione a turno per farle soddisfare i requisiti delle funzioni da cui dipendono, ma questo ci richiede di comprendere appieno tutti i moduli e avere la capacità di modificarli. Questo è completamente impossibile da ottenere quando si sviluppa una collaborazione tra più persone o quando si utilizzano moduli di terze parti.

Pertanto, tutti i moduli comuni devono fornire interfacce di sincronizzazione e asincronia per bilanciare l'equilibrio tra asincronia e prestazioni. Gli sviluppatori più ordinari sceglieranno di fornire solo un'interfaccia asincrona. Questo porta a un disastro delle 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 convertire funzioni di callback o asincrone in funzioni di sincronizzazione e chiamarle direttamente. In questo modo, possiamo facilmente integrare moduli di diversi paradigmi di programmazione e convertirli in paradigmi di sincronizzazione con costi di sviluppo minimi, evitando efficacemente i disastri causati dall'infezione del paradigma.

Inizia l'esperienza

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

👉 [ Installazione e ambiente operativo ]