Estoy usando OLN para algunos espacios de nombres básicos en algunos archivos javascript. La "jerarquía lógica" de esos archivos es algo como esto:
-main.js -somefile.js -otherfile.js -....main.js administra las cosas que todas las páginas necesitan, pero luego, dependiendo de la página específica cargada, se puede cargar somefile.js u otherfile.js (o ninguno).
En main.js, esta es la sintaxis:
principal.js
var mainjs = { someobjects: [baz], // more stuff }Según la página cargada, se cargan otros archivos javascript. Podrían agregar objetos a esa lista, así:
algúnarchivo.js
let foo; let bar; $(function() { console.log( " somefile.js ready!" ); mainjs.someobjects = mainjs.someobjects.concat([foo, bar]) } Si miro en la consola después de cargar la página, puedo ver que dentro de mainjs.someobjects , tengo esos 3 objetos. "baz" está definido y los otros 2 que agregué son "indefinidos". Está bien.
Sin embargo, cuando más tarde inicialicé esos 2 objetos de somefile.js (el usuario hace clic en algo), luego en la consola puedo ver que tanto foo como bar están definidos. Sin embargo, en mainjs.someobjects , los 2 objetos aún no están definidos.
Pensé que se pasarían como referencia, pero aparentemente me equivoqué. Básicamente, el problema que estoy tratando de abordar es que tengo algunos somefile.js diferentes que pueden crear diferentes objetos (tablas de datos en realidad) pero obtienen los datos (llamadas aajax) solo cuando se muestra la pestaña que los contiene. Luego necesito ajustar los anchos de las columnas según los datos. Un problema conocido con tablas de datos, cuando el html se crea antes de que se complete la tabla de datos. Se necesita una llamada a table.columns.adjust() para que eso suceda.
Asi que:
mainjs aún no están definidas y quién puedo cambiar mi estructura para que cuando esas variables se asignen más tarde a objetos, en realidad hagan referencia al objeto?Pensé que se pasarían como referencia, pero aparentemente me equivoqué.
Sí, JavaScript es un lenguaje puramente de paso por valor, aparte de algo que hacen los módulos nativos de JavaScript ("ESM").
Me parece que quieres usar ESM. En ESM, cuando exporta un enlace a nivel de módulo (sin apretar, "variable") y otro módulo lo importa, el otro módulo tiene un enlace en vivo de solo lectura que lo vincula con el exportado original. Eso significa que cuando el módulo que lo importó lo usa, ve el valor actual del enlace de origen (no el valor que tenía cuando se exportó).
Entonces, si estaba usando ESM y lo hizo:
export let foo; export let bar; // ...code here that asynchronously or periodically updates `foo` and/or `bar`...Luego un módulo importándolos:
import {foo, bar} from "./some-module.js"; ... verá los valores actuales de foo y bar a través de esos enlaces en vivo.
Si no desea utilizar ESM por algún motivo, puede exportar un objeto con propiedades para foo y bar y hacer que el otro código utilice ese objeto exportado. Dado que el objeto es estable (no lo reemplazamos con un objeto diferente), el código que lo usa puede acceder de manera confiable a sus propiedades foo y bar y ver sus valores actuales.
Básicamente, en somefile.js :
const meaningfulName = { foo: undefined, // Or some more meaningful initial value bar: undefined, // Or some more meaningful initial value }; $(function() { console.log( " somefile.js ready!" ); // Just FWIW, I probably woudn't use an array for this, I'd use an object mainjs.someobjects = mainjs.someobjects.concat(meaningfulName); } Luego, el código que usa ese objeto usaría sus propiedades foo y bar , y siempre vería el valor actual de ellas.