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 de backend web, se basa en el motor JavaScript v8 de Google y elige una solución concurrente 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 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 la programación asincrónica como el paradigma principal de programación.

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

De vuelta al verdadero desarrollo á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, se realiza 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 buscas simplicidad, incluso puedes escribir el código de esta manera:

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 entre dos estilos de programación diferentes. Menos código conduce a menos errores y, a medida que el código disminuye, la lógica del código se vuelve más clara y se beneficia tanto del desarrollo como del mantenimiento.

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 razones 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 un código de prueba para comparar las diferencias de rendimiento causadas 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();

Bajo la última v8 v6.7.192, este código se ejecuta de la siguiente manera:

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

A partir de 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 devolución de la función asíncrona. También encontramos esto en las pruebas reales de algunas aplicaciones del lado del servidor. Y la fuerte caída en el rendimiento es completamente inaceptable.

Debido a que fibjs usa fibra, puede hacer un uso completo de las características del lenguaje JavaScript en sí mismo 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ónica que haya visto y tiene la flexibilidad de cambiar entre estilos sincrónicos y asincrónicos.

Ya sea que se trate de devolución de llamada o asíncrono, existe un defecto fatal, que es el contagio. Mientras 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. Al comienzo del proyecto, elegimos la memoria como el almacenamiento de datos de la sesión. En este momento, podemos leer y almacenar datos directamente utilizando el método de sincronización, 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 para hacer que cumplan con los requisitos de la función dependiente, pero esto requiere que comprendamos todos los módulos y tengamos la capacidad de modificarlos. Esto es completamente imposible durante 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. Esto puede conducir a desastres de rendimiento.

En fibjs, puede resolver fácilmente problemas similares y evitar la transmisión asincrónica y no controlada explícita:

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 manera, 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 el desastre provocado por la infección de paradigma.

Comienza experiencia

¿Listo para comenzar una experiencia de desarrollo agradable? Entonces, comencemos con la instalación.

👉 [entorno de instalación y operación ]