Guía de desarrollo de la guía

¿Qué es fibjs?

fibjs es un marco de desarrollo de servidor de aplicaciones diseñado principalmente para el desarrollo web back-end. Está construido en el motor de JavaScript de Google v8 y selecciona una solución de concurrencia diferente a la devolución de llamada tradicional. Fibjs usa fibra para aislar la complejidad del negocio causada por las llamadas asincrónicas en la capa de marco, lo que reduce en gran medida la dificultad de desarrollo y reduce los problemas de rendimiento causados ​​por el procesamiento asincrónico frecuente en el espacio del usuario.

Por razones históricas, JavaScript se utiliza principalmente para el procesamiento de la interfaz de usuario en los navegadores.El desarrollo de la interfaz de usuario es un modelo típico basado en eventos de un solo subproceso, por lo que JavaScript también ha formado el procesamiento asincrónico como el principal paradigma de programación.

Con el éxito de JavaScript, cada vez más personas comenzaron a aplicar JavaScript a otros escenarios. Al mismo tiempo, la gente está descubriendo cada vez más que el procesamiento asincrónico no es la opción más adecuada en muchos escenarios.

Volver al desarrollo original y ágil

Fibjs utiliza fibra en la capa de marco para aislar la complejidad empresarial causada por las llamadas asincrónicas y encapsula el procesamiento asincrónico de io en llamadas síncronas más intuitivas. Los ingenieros solo necesitan escribir código de acuerdo con la lógica comercial síncrona habitual para disfrutar de los beneficios del procesamiento asincrónico. Gran comodidad

El siguiente código está tomado de la documentación del 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 el mismo trabajo, el código es el siguiente:

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 persigue la simplicidad, incluso puede escribir código como este:

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 las diferencias traídas por dos estilos de programación diferentes. Menos código traerá menos errores y, a medida que el código disminuye, la lógica del código se vuelve más clara, ya sea desarrollo o mantenimiento, se beneficiará de ello.

Abraza la alta energía

Aunque podemos aumentar fácilmente la velocidad de respuesta al expandir el servidor, el rendimiento aún debería ser una de las bases importantes para elegir un marco de desarrollo. Con la introducción de ES7, async se introdujo en JavaScript como un nuevo modelo de desarrollo asincrónico. Sin embargo, cuando disfrutamos del estilo de sincronización que brinda async, también tenemos que enfrentar su impacto en el rendimiento.

Podemos usar una pieza de código de prueba para comparar las diferencias de rendimiento que generan los 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();

Bajo la última v8 v6.7.192, los resultados de esta ejecución de código son los siguientes:

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

Por los resultados de la prueba, podemos saber claramente que cuando la asíncrona se usa ampliamente en el proyecto, el servidor pasará mucho tiempo procesando la llamada y la función de la función asíncrona. También encontramos esto en las pruebas reales de algunas aplicaciones de servidor. Y esta fuerte disminución en el rendimiento es completamente inaceptable.

Dado que fibjs usa fibra, puede hacer un uso completo de las características del lenguaje JavaScript y maximizar el rendimiento superior de v8. Los ingenieros pueden maximizar fácilmente el rendimiento del servidor.

Elección flexible de paradigma sin ser secuestrado

Elegir utilizar fibjs no significa que deba usar un estilo de desarrollo sincrónico. De hecho, fibjs admite cualquier paradigma de programación asincrónico que haya visto y puede cambiar de manera flexible entre el estilo sincrónico y el estilo asincrónico.

Ya sea que se trate de devolución de llamada o asíncrono, existe una falla fatal que es contagiosa. Siempre que una función sea devolución de llamada o asíncrona, todas las demás funciones que dependen de ella deben ser devolución de llamada o asíncrona. Esto traerá enormes costos de desarrollo en el desarrollo de software a gran escala.

Tome un escenario de desarrollo de servidor simple como ejemplo. En la etapa inicial del proyecto, elegimos la memoria como el almacenamiento de datos de la sesión. En este momento, podemos usar la sincronización para leer y almacenar datos directamente, y desarrollar un negocio completo basado en esto. Con el desarrollo de la escala comercial, necesitamos almacenar datos de sesión en redis o mongodb. En este momento, necesitamos modificar las operaciones relacionadas con la sesión al modo asíncrono.

En teoría, podemos modificar cada función a su vez para hacer que se ajusten a los requisitos de las funciones de las que depende, pero esto requiere que comprendamos completamente todos los módulos y tengamos la capacidad de modificarlos. Esto es completamente imposible cuando el desarrollo colaborativo de varias personas o cuando se utilizan módulos de terceros.

Por lo tanto, todos los módulos comunes deben proporcionar interfaces de sincronización y asíncrona para equilibrar el equilibrio entre asíncrono y rendimiento. Los desarrolladores más comunes elegirán proporcionar solo una interfaz asíncrona. Por lo tanto, causando desastres de rendimiento

En fibjs, puede resolver fácilmente problemas similares y evitar infecciones asincrónicas y no controladas 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 puede usar util.sync para convertir las funciones de devolución de llamada o asíncrona en funciones de sincronización y llamarlas directamente. De esta forma, podemos integrar fácilmente módulos de diferentes paradigmas de programación y transformarlos en paradigmas de sincronización con costos de desarrollo mínimos, evitando efectivamente los desastres causados ​​por el contagio de paradigmas.

Comienza a experimentar

¿Estás listo para comenzar una experiencia de desarrollo agradable? Entonces, comience con la instalación.

👉 【 Instalación y entorno operativo