Guía Guía de desenvolvemento

Que é fibjs?

fibjs é un marco de desenvolvemento de servidor de aplicacións deseñado principalmente para o desenvolvemento de back-end web. Está baseado no motor JavaScript de Google v8 e elixe unha solución concorrente diferente da devolución de chamada tradicional. fibjs usa fibra para illar a complexidade empresarial causada por chamadas asíncronas na capa de marco, o que reduce moito a dificultade de desenvolvemento e reduce os problemas de rendemento causados ​​polo procesamento asíncrono frecuente no espazo do usuario.

Por razóns históricas, JavaScript úsase principalmente para o procesamento da interface de usuario do navegador. O desenvolvemento da interface de usuario é un modelo baseado nun evento típico dun só fío. Por iso, JavaScript tamén formou un paradigma de programación co procesamento asíncrono como paradigma de programación principal.

Co éxito de JavaScript, cada vez hai máis xente que comeza a aplicar JavaScript a outros escenarios. Ao mesmo tempo, a xente cre cada vez máis que o procesamento asíncrono non é a opción máis adecuada en moitos escenarios.

Volver ao básico, desenvolvemento áxil

fibjs usa fibra na capa marco para illar a complexidade empresarial causada por chamadas asíncronas e encapsula o procesamento asíncrono de io nunha chamada síncrona máis intuitiva. Os enxeñeiros só precisan escribir código de acordo coa lóxica de negocio síncrona habitual para gozar das vantaxes de procesamento asíncrono. Gran comodidade.

O seguinte código está extraído da documentación do módulo 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!'); }); }); }); });

En fibjs, para completar o mesmo traballo, o código é o seguinte:

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 buscas brevidade, incluso podes escribir o código así:

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

Podemos comparar claramente as diferenzas provocadas por dous estilos de programación diferentes. Menos código traerá menos erros. A medida que o código diminúe, a lóxica do código é máis clara. O desenvolvemento e o mantemento beneficiaranse del.

Abraza alta enerxía

Aínda que podemos aumentar facilmente a velocidade de resposta expandindo o servidor, o rendemento debería ser unha das bases importantes para escoller un marco de desenvolvemento. Coa introdución de ES7, async introduciuse en JavaScript como un novo modelo de desenvolvemento asíncrono. Non obstante, cando gozamos do estilo de sincronización traído por async, tamén temos que afrontar o seu impacto no rendemento.

Podemos usar un código de proba para comparar as diferenzas de rendemento provocadas por diferentes estilos de programación:

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

Segundo o último v8, os resultados deste código son os seguintes:

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

Podemos saber claramente polos resultados da proba que cando o async se usa moito no proxecto, o servidor pasará moito tempo procesando chamadas e devolucións de función async. Tamén atopamos este punto na proba real dalgunhas aplicacións do servidor. E este tipo de forte caída do rendemento é totalmente inaceptable.

Debido a que fibjs usa fibra, pode facer un pleno uso das características da propia linguaxe JavaScript e maximizar o rendemento superior de v8. Os enxeñeiros poden maximizar facilmente o rendemento do servidor.

Elección flexible do paradigma sen ser secuestrado

Escoller usar fibjs non significa que teñas que usar un estilo de desenvolvemento síncrono. De feito, fibjs admite calquera paradigma de programación asíncrono que viches e pode cambiar de xeito flexible entre estilos síncronos e asíncronos.

Tanto a devolución de chamada como a sincronización teñen un fallo fatal, que é o contaxio. Mentres unha función sexa de devolución de chamada ou asíncrona, todas as outras funcións que dependan dela deben ser de devolución de chamada ou asíncronas. Isto traerá enormes custos de desenvolvemento no desenvolvemento de software a grande escala.

Tomemos como exemplo un sinxelo escenario de desenvolvemento do servidor. Ao comezo do proxecto, escollemos a memoria como almacenamento de datos de sesión. Neste momento, podemos ler e almacenar directamente os datos usando o método de sincronización e desenvolver un negocio completo baseado nisto. Co desenvolvemento da escala empresarial, necesitamos almacenar os datos da sesión en redis ou mongodb. Neste momento, necesitamos modificar as operacións relacionadas coa sesión ao modo asincrónico.

En teoría, podemos modificar cada función á súa vez para que cumpran os requisitos das funcións das que dependen, pero isto require que entendamos completamente todos os módulos e teñamos a capacidade de modificalos. Isto é completamente imposible de lograr cando se desenvolve unha colaboración multipersonal ou se se utilizan módulos de terceiros.

Polo tanto, todos os módulos comúns precisan proporcionar interfaces sincronizadas e asíncronas para equilibrar o equilibrio entre asincronía e rendemento. Os desenvolvedores máis comúns optarán por fornecer só a interface asíncrona. Isto leva a un desastre de rendemento.

En fibjs, pode resolver facilmente problemas similares e evitar infeccións asíncronas e sen control explícitas:

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 pode usar util.sync para converter funcións de devolución de chamada ou asíncronas en funcións de sincronización e chamalas directamente. Deste xeito, podemos integrar facilmente módulos de diferentes paradigmas de programación e transformalos en paradigmas de sincronización con custos de desenvolvemento mínimos, evitando efectivamente os desastres causados ​​polo contaxio do paradigma.

Comeza a experimentar

¿Está preparado para comezar unha experiencia de desenvolvemento agradable? Entón, imos comezar coa instalación.

👉 [Contorno de instalación e operación ]