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 de concurrencia diferente a la devolución de llamada tradicional. Fibjs utiliza fibra para aislar la complejidad empresarial que generan 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 frecuente procesamiento asincrónico del espacio del usuario.

Por razones históricas, JavaScript se utiliza principalmente para el procesamiento de la interfaz de usuario del navegador. El desarrollo de la interfaz de usuario es un modo típico basado en eventos de un solo subproceso, por lo que JavaScript también forma 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, la gente encuentra cada vez más que el procesamiento asincrónico no es la opción más adecuada en muchos escenarios.

Regresar al desarrollo original y ágil

Fibjs usa fibra en la capa de marco para aislar la complejidad del negocio que generan 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, que puede ser disfrutada por el procesamiento asincrónico. Gran comodidad

El siguiente código se toma de la documentación para el 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, haga lo mismo, 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 busca la simplicidad, incluso puede 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 los dos estilos de programación diferentes. Menos código conduce a menos errores y, a medida que se reduce el código, la lógica del código es más clara y se beneficiarán tanto el desarrollo como el mantenimiento.

Abraza la alta energía

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

Podemos usar un código de prueba para comparar las diferencias de rendimiento entre 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, el resultado de este código es el siguiente:

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

Podemos ver claramente en los resultados de la prueba que cuando la sincronización asíncrona se usa ampliamente en un proyecto, el servidor pasará mucho tiempo procesando la llamada y la devolución de la función asincrónica. También encontramos esto en las pruebas reales de algunas aplicaciones de servidor. Y esta fuerte disminución en el rendimiento es totalmente inaceptable.

Fibjs usa fibra para aprovechar al máximo las características del lenguaje JavaScript y maximizar el rendimiento de v8. Los ingenieros pueden maximizar fácilmente el rendimiento de sus servidores.

Elección flexible de paradigma sin ser secuestrado

Elegir utilizar fibjs no significa que tenga que 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 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. Al comienzo del proyecto, elegimos la memoria como el almacén de datos de la sesión. En este punto, podemos usar el método de sincronización para leer y almacenar datos directamente, y en base a esto, desarrollar un negocio completo. A medida que crece la escala comercial, necesitamos almacenar los datos de la sesión en redis o mongodb. En este punto, necesitamos modificar las operaciones relacionadas con la sesión al modo asíncrono.

En teoría, podemos modificar cada función para que coincida con los requisitos de la función de la que depende, pero esto requiere que comprendamos todos los módulos y tengamos la capacidad de modificarlos. Esto es completamente imposible de hacer 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. Más desarrolladores normales elegirán proporcionar solo la interfaz asíncrona. Esto provoca un desastre de rendimiento.

En fibjs, puede resolver fácilmente problemas similares y evitar una infección asincrónica incontrolada 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 una función de devolución de llamada o asíncrona en una función de sincronización y llamarla directamente. De esta forma, podemos integrar fácilmente módulos de diferentes paradigmas de programación y transformarlos en paradigmas de sincronización con un costo de desarrollo mínimo, evitando efectivamente el desastre causado por la infección de paradigma.

Comienza la experiencia

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

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