Cos'è fibjs?

fibjs è un framework di sviluppo di server applicativi progettato principalmente per lo sviluppo di back-end Web. Si basa sul motore JavaScript di Google v8 e sceglie una soluzione di concorrenza diversa dal callback tradizionale. fibjs utilizza la fibra per isolare la complessità aziendale causata dalle chiamate asincrone a livello di framework, riducendo notevolmente la difficoltà di sviluppo e riducendo 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 dei browser.Lo sviluppo dell'interfaccia utente è un tipico modello basato su eventi a thread singolo, quindi JavaScript ha anche formato l'elaborazione asincrona come paradigma di programmazione principale.

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 è la scelta più adatta in molti scenari.

Ritorno alle origini, sviluppo agile

fibjs utilizza la fibra nel livello del framework per isolare la complessità aziendale portata dalle chiamate asincrone e incapsula l'elaborazione asincrona di io in chiamate sincrone più intuitive.Gli ingegneri devono solo scrivere codice secondo la normale logica aziendale sincrona per godere dei vantaggi offerti dall'asincrono elaborazione Grande convenienza.

Il seguente frammento di codice è tratto dalla documentazione per il 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 eseguire 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 cerchi la brevità, puoi persino scrivere il tuo 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 causate dai due diversi stili di programmazione. Meno codice porterà meno errori Con la riduzione del codice, la logica del codice sarà più chiara e sia lo sviluppo che la manutenzione ne beneficeranno.

abbracciare 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 godiamo lo stile sincrono offerto da async, dobbiamo anche affrontare il suo impatto sulle prestazioni.

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

Sotto l'ultima v8, il risultato di questo codice è il seguente:

1
2
3
async: 0.539ms
callback: 0.221ms
sync: 0.061ms

Possiamo chiaramente sapere dai risultati del test che quando async è ampiamente utilizzato nel progetto, il server impiegherà molto tempo a elaborare la chiamata e il ritorno delle funzioni asincrone. Lo abbiamo riscontrato anche in alcuni test effettivi di applicazioni lato server. E questo forte calo delle prestazioni è del tutto 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 rapiti

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

Che si tratti di callback o async, c'è un difetto fatale, ovvero il contagio. Finché una funzione è callback o async, tutte le altre funzioni che dipendono da essa devono essere callback o async. 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 di sessione.In questo momento, 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, abbiamo bisogno di archiviare i dati della sessione in redis o mongodb. A questo punto, dobbiamo modificare le operazioni relative alla sessione in modalità asincrona.

In teoria, possiamo modificare ciascuna funzione a turno per far sì che soddisfino i requisiti delle funzioni da cui dipendono, ma questo richiede che comprendiamo appieno tutti i moduli e abbiamo la capacità di modificarli. Questo è completamente impossibile quando si sviluppa in collaborazione tra più persone o quando si utilizzano moduli di terze parti.

Pertanto, tutti i moduli comuni devono fornire entrambe le interfacce di sincronizzazione e asincrona per bilanciare l'equilibrio tra asincronia e prestazioni. Gli sviluppatori più ordinari sceglieranno di fornire solo interfacce asincrone. Causando così un disastro di prestazioni.

In fibjs, puoi facilmente risolvere problemi simili, evitando il contagio incontrollato asincrono esplicito:

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 una funzione di callback o asincrona in una funzione di sincronizzazione e chiamarla direttamente. In questo modo, possiamo facilmente integrare moduli di diversi paradigmi di programmazione e trasformarli in paradigmi di sincronizzazione con costi di sviluppo minimi, evitando efficacemente disastri causati dal contagio del paradigma.

iniziare a fare esperienza

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

👉 【Ambiente di installazione e funzionamento】