Todo funciona bien cuando escribí la lógica js en un cierre como un solo archivo js, ​​como:

(function(win){
   //main logic here
   win.expose1 = ....
   win.expose2 = ....
})(window)

pero cuando trato de insertar una función alternativa de registro antes de ese cierre en el mismo archivo js,

 window.Glog = function(msg){
     console.log(msg)
 }
 // this was added before the main closure.

 (function(win){
   //the former closure that contains the main javascript logic;
 })(window)

se queja de que hay un TypeError:

Uncaught TypeError: (intermediate value)(...) is not a function

¿Qué hice mal?

El error es el resultado del punto y coma que falta en la tercera línea:

window.Glog = function(msg) {
  console.log(msg);
}; // <--- Add this semicolon

(function(win) {
  // ...
})(window);

La especificación ECMAScript tiene reglas específicas para la inserción automática de punto y coma , sin embargo, en este caso, un punto y coma no se inserta automáticamente porque la expresión entre paréntesis que comienza en la línea siguiente se puede interpretar como una lista de argumentos para una llamada a la función.

Esto significa que sin ese punto y coma, la window.Glogfunción anónima se invocaba con una función como msgparámetro, seguido de lo (window)cual posteriormente se intentaba invocar lo que se devolvió.

Así es como se interpretaba el código:

window.Glog = function(msg) {
  console.log(msg);
}(function(win) {
  // ...
})(window);

Para simplificar las reglas de punto y coma

Cada línea que comienza con una (, [, `, o cualquier operador (/, +, - son los únicos válidos), debe comenzar con un punto y coma.

func()
;[0].concat(myarr).forEach(func)
;(myarr).forEach(func)
;`hello`.forEach(func)
;/hello/.exec(str)
;+0
;-0

Esto evita un

func()[0].concat(myarr).forEach(func)(myarr).forEach(func)`hello`.forEach(func)/hello/.forEach(func)+0-0

monstruosidad

Nota adicional

Para mencionar lo que sucederá: los paréntesis se indexarán, los paréntesis se tratarán como parámetros de función. El backtick se transformaría en una plantilla etiquetada , y las expresiones regulares o enteros con signo explícito se convertirán en operadores. Por supuesto, puede agregar un punto y coma al final de cada línea. Sin embargo, es bueno tener en cuenta cuando realiza prototipos rápidamente y deja caer los puntos y comas.

Además, agregar puntos y comas al final de cada línea no lo ayudará con lo siguiente, así que tenga en cuenta declaraciones como

return // Will automatically insert semicolon, and return undefined.
    (1+2);
i // Adds a semicolon
   ++ // But, if you really intended i++ here, your codebase needs help.

El caso anterior sucederá para devolver / continuar / romper / ++ / -. Cualquier linter captará esto con código muerto o error de sintaxis ++ / - (++ / - nunca ocurrirá de manera realista).

Finalmente, si desea que funcione la concatenación de archivos, asegúrese de que cada archivo termine con un punto y coma. Si está utilizando un programa de paquete (recomendado), debería hacerlo automáticamente.

Caso de error:

var userListQuery = {
    userId: {
        $in: result
    },
    "isCameraAdded": true
}

( cameraInfo.findtext != "" ) ? searchQuery : userListQuery;

Salida:

TypeError: (intermediate value)(intermediate value) is not a function

Solución: le falta un punto y coma (;) para separar las expresiones

userListQuery = {
    userId: {
        $in: result
    },
    "isCameraAdded": true
}; // Without a semi colon, the error is produced

( cameraInfo.findtext != "" ) ? searchQuery : userListQuery;

Para mí fue mucho más simple, pero me llevó un tiempo resolverlo. Básicamente teníamos en nuestro .jslib

some_array.forEach(item => {
    do_stuff(item);
});

Resulta que Unity (¿emscripten?) Simplemente no le gusta esa sintaxis. Lo reemplazamos con un viejo bucle for y dejó de quejarse de inmediato. Realmente odio que no muestre la línea de la que se está quejando, pero de todos modos, engañarme dos veces la vergüenza.

Me enfrenté a este problema cuando creé una nueva clase ES2015 donde el nombre de la propiedad era igual al nombre del método.

p.ej:

class Test{
  constructor () {
    this.test = 'test'
  }

  test (test) {
    this.test = test
  }
}

let t = new Test()
t.test('new Test')

Tenga en cuenta que esta implementación estaba en NodeJS 6.10.

Como solución alternativa (si no desea utilizar el aburrido nombre del método 'setTest'), puede utilizar un prefijo para sus propiedades 'privadas' (como _test).

Abra sus herramientas de desarrollador en jsfiddle .

  **Error Case:**

var handler = function(parameters) {
  console.log(parameters);
}

(function() {     //IIFE
 // some code
})();

Salida: TypeError: (valor intermedio) (valor intermedio) no es una función * Cómo arreglar IT -> porque le falta semi colan (;) para separar las expresiones;

 **Fixed**


var handler = function(parameters) {
  console.log(parameters);
}; // <--- Add this semicolon(if you miss that semi colan .. 
   //error will occurs )

(function() {     //IIFE
 // some code
})();

¿Por qué viene este error? Motivo: reglas específicas para la inserción automática de punto y coma a las que se otorgan estándares ES6

Cuando creo una clase raíz, cuyos métodos definí usando las funciones de flecha. Al heredar y sobrescribir la función original, noté el mismo problema.

class C {
  x = () => 1; 
 };
 
class CC extends C {
  x = (foo) =>  super.x() + foo;
};

let add = new CC;
console.log(add.x(4));

esto se resuelve definiendo el método de la clase padre sin funciones de flecha

class C {
  x() { 
    return 1; 
  }; 
 };
 
class CC extends C {
  x = foo =>  super.x() + foo;
};

let add = new CC;
console.log(add.x(4));