Guía de desarrollo de guías

¿Qué es fibjs?

fibjs es un marco de desarrollo de servidor de aplicaciones diseñado principalmente para el desarrollo de back-end web. Se basa en el motor JavaScript de Google v8 y elige una solución concurrente diferente de la devolución de llamada tradicional. fibjs usa fibra para aislar la complejidad empresarial causada por las llamadas asincrónicas en la capa del 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.

Debido a 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 modelo típico impulsado por eventos de un solo subproceso. Por lo tanto, JavaScript también ha formado un paradigma de programación con el procesamiento asíncrono 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 a lo básico, 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 una llamada sincrónica más intuitiva. Los ingenieros solo necesitan escribir código de acuerdo con la lógica comercial sincrónica habitual para disfrutar de los beneficios del procesamiento asincrónico. Gran conveniencia.

El siguiente código se toma 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 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 provocadas por dos estilos de programación diferentes. Menos código traerá menos errores. A medida que el código disminuye, la lógica del código se vuelve más clara. Tanto el desarrollo como el mantenimiento se beneficiarán de ello.

Abraza la alta energía

Aunque podemos aumentar fácilmente la velocidad de respuesta ampliando el servidor, el rendimiento debe seguir siendo 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 trae el async, también tenemos que afrontar su impacto en el rendimiento.

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

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

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

Podemos saber claramente por los resultados de la prueba que cuando async se usa ampliamente en el proyecto, el servidor pasará mucho tiempo procesando las llamadas y devoluciones de funciones async. También hemos encontrado este punto en las pruebas reales de algunas aplicaciones del lado del servidor. Y esta fuerte caída en el rendimiento es totalmente inaceptable.

Debido a que fibjs usa fibra, puede aprovechar al máximo 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 usar 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 puede cambiar de manera flexible entre estilos sincrónico y asincrónico.

Tanto la devolución de llamada como la asincrónica tienen un defecto fatal, que es el contagio. Siempre que una función sea callback o async, todas las demás funciones que dependen de ella deben ser callback o async. Esto traerá enormes costos de desarrollo en el desarrollo de software a gran escala.

Tomemos como ejemplo un escenario de desarrollo de servidor simple. Al inicio del proyecto, elegimos la memoria como almacenamiento de datos de la sesión, en este momento podemos leer y almacenar directamente los datos mediante el método de sincronización y desarrollar un negocio completo en base a esto. Con el desarrollo de la escala empresarial, necesitamos almacenar los datos de la 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 que cumplan con los requisitos de las funciones de las que dependen, pero esto requiere que comprendamos completamente todos los módulos y tengamos la capacidad de modificarlos. Esto es completamente imposible cuando se trata de un desarrollo colaborativo de varias personas o cuando se utilizan módulos de terceros.

Por lo tanto, todos los módulos comunes deben proporcionar interfaces sincronizadas y asincrónicas para equilibrar el equilibrio entre la asincronía y el rendimiento. Los desarrolladores más comunes optarán por proporcionar solo una interfaz asíncrona. Esto conduce a un desastre de rendimiento.

En fibjs, puede resolver fácilmente problemas similares y evitar infecciones asincrónicas explícitas y no controladas:

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 funciones de devolución de llamada o asíncronas 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 sincronizados con costos mínimos de desarrollo, evitando efectivamente los desastres provocados por el contagio de paradigmas.

Iniciar experiencia

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

👉 [Entorno de instalación y funcionamiento ]