Estoy escribiendo un programa con varios hilos y muchos requisitos. Necesito dependencias circulares, de lo contrario habrá demasiados archivos.
Tengo una función que puede evitar que se reproduzca en bucle, sin embargo, el nodo se queja antes de que pueda ejecutarse. Intenté buscar una forma, pero es difícil encontrar un "desvío" en lugar de mover muchas cosas.
¿Es posible desactivar las protecciones y dejar que se ejecute de todos modos?
Aquí está mi código;
constantes.js
// This should prevent any circular dependency but node shuts it down too eagerly. function _getCallerFile() { // Returns the file that originally called. var err = new Error(); Error.prepareStackTrace = (_, stack) => stack; Error.prepareStackTrace = undefined; return err.stack.toString(); } var x = _getCallerFile(); console.log(x); console.log(x.includes(".js")) console.log(x.includes("threading.js")) //if (!x.includes("input.js")) var input = require('./constants/input.js'); if (!x.includes("threading.js")) var threading = require('./constants/threading.js'); module.exports ={ threading: threading //input: input };enhebrar.js
var x = require('../constants.js'); module.exports.init = async function (whoami) { x.sendMsg("debug", whoami, `Starting!`); }índice.js
var x = require('./constants.js'); async function main() { x.threading.init(whoami); } main();Node.JS ¿Es posible evitar que el nodo detenga la ejecución de dependencias circulares?
Nodejs no puede ejecutarse con muchos tipos de dependencias circulares. Hay algunas maneras en las que puedes vivir con ciertas cosas si eres muy, muy cuidadoso en cómo escribes tu código, en qué orden defines las cosas y en qué orden haces referencia a las cosas. Mira la descripción aquí para más detalles, pero en general, es mucho más seguro simplemente eliminar la dependencia circular en su totalidad en lugar de tratar de vivir con ella o codificar a su alrededor.
Imagine la responsabilidad de mantenimiento de su código si crea con mucho cuidado una dependencia circular que realmente funciona debido al momento cuidadoso en el que declara y accede a las cosas y luego una modificación aparentemente inocente en el código de repente rompe las cosas. En general, es más seguro no tener dependencias circulares y, por lo general, una pequeña refactorización en archivos compartidos puede resolverlo de manera fácil y segura.
La solución habitual aquí es volver a trabajar en el diseño de su código para evitar crear la dependencia circular en primer lugar. Siempre es posible dividir un código común en un archivo compartido y evitar la dependencia circular y debería poder hacerlo sin crear un millón de archivos.
En algunos casos, es más sencillo combinar dos archivos en un solo archivo donde puede tener dependencias de código circular entre, digamos, dos clases dentro del mismo archivo. Si muestra el código real con el problema real, podemos recomendarle buenas opciones para evitar la dependencia circular.
En su ejemplo específico, podría evitarlo retrasando una de sus declaraciones require() . Por ejemplo, si cambia parte de threading.js de esto:
var x = require('../constants.js'); module.exports.init = async function (whoami) { x.sendMsg("debug", whoami, `Starting!`); }a esto:
module.exports.init = async function (whoami) { var x = require('../constants.js'); x.sendMsg("debug", whoami, `Starting!`); } Entonces, ya no se encuentra con la dependencia circular porque threading.js no carga constants.js hasta DESPUÉS de que threading.js ya haya terminado de cargarse. O, otra forma de verlo, es que threading.js se carga sin requerir constants.js , evitando así la circularidad durante la carga. Tenga en cuenta que esto no se traducirá también a los módulos ESM que requieren que las importaciones dinámicas (no estáticas) sean asincrónicas y usen la versión de función de import() que devuelve una promesa.
Esto cargará constants.js en la primera llamada a .init() , lo cual no es ideal, pero una vez que se cargue por primera vez, vendrá del caché del módulo cada vez que lo haga.
Todavía sugeriría personalmente refactorizar para evitar esto, pero hay algunos trucos con el tiempo de carga que pueden evitar la circularidad.
Quizás estés complicando las cosas aquí.
Mirar su código usando el truco _getCallerFile para intentar y requerir automáticamente parece un problema esperando a suceder. p.ej. ¿Qué pasaría si tuvieras legítimamente dos copias de threading.js ?
A continuación se muestra su código ajustado para que funcione de la manera que desee sin tener que implementar ningún elemento original.
constantes.js
module.exports ={ // threading: threading <- filled during bootstrap stage };enhebrar.js
var x = require('../constants.js'); async function init(whoami) { x.sendMsg("debug", whoami, `Starting!`); } //bootstrap x.threading = init; module.exports = init;índice.js
require('./threading.js'); //bootstrap var x = require('./constants.js'); async function main() { x.threading.init(whoami); } main();Lo que es aún mejor, hacerlo de esta manera funcionará si alguna vez decidiste usar el cargador de módulos ES, o si querías comenzar a usar TypeScript.