¿Qué significa "var FOO = FOO / / {}" (asignar una variable o un objeto vacío a esa variable) en Javascript?

var AEROTWIST = AEROTWIST || {};

Básicamente esta línea dice establecer la variable AEROTWIST al valor de la variable AEROTWIST, o establecerla en un objeto vacío.

La tubería doble || es una instrucción OR, y la segunda parte del OR solo se ejecuta si la primera parte devuelve false.

Por lo tanto, si AEROTWIST ya tiene un valor, se mantendrá como ese valor, pero si no se ha establecido antes, entonces se establecerá como un objeto vacío.

Es básicamente lo mismo que decir esto:

if(!AEROTWIST) {var AEROTWIST={};}

Esperanza eso ayuda.

Otro uso común para | / es establecer un valor predeterminado para un parámetro de función indefinido también:

function display(a) {
  a = a || 'default'; // here we set the default value of a to be 'default'
  console.log(a);
}

// we call display without providing a parameter
display(); // this will log 'default'
display('test'); // this will log 'test' to the console

El equivalente en otra programación generalmente es:

function display(a = 'default') {
  // ...
}

Hay dos partes principales que var FOO = FOO || {}; cubre.

#1 Prevención de anulaciones

Imagine que tiene su código dividido en varios archivos y sus compañeros de trabajo también están trabajando en un Objeto llamado FOO. Entonces podría llevar al caso de que alguien ya definiera FOO y le asignara funcionalidad (como una función skateboard). Entonces lo anularía, si no estuviera comprobando si ya existe.

Caso problemático:

// Definition of co-worker "Bart" in "bart.js"
var FOO = {};

FOO.skateboard = function() {
  alert('I like skateboarding!');
};

// Definition of co-worker "Homer" in "homer.js"
var FOO = {};

FOO.donut = function() {
  alert('I like donuts!');
};

En en este caso, la función skateboard desaparecerá si carga el archivo JavaScript homer.js después de bart.js en su HTML porque Homer define un nuevo objeto FOO (y por lo tanto anula el existente de Bart) para que solo conozca la función donut.

Así que necesitas usar var FOO = FOO || {}; que significa "FOO se asignará a FOO (si ya existe) o a un nuevo objeto en blanco (si FOO no existe ya).

Solución:

var FOO = FOO || {};

// Definition of co-worker Bart in bart.js
FOO.skateboard = function() {
  alert('I like skateboarding!');
};

// Definition of co-worker Homer in homer.js
var FOO = FOO || {};

FOO.donut = function() {
  alert('I like donuts!');
};

Porque Bart y Homer ahora están buscando la existencia de FOO antes de que definan sus métodos, puede cargar bart.js y homer.js en cualquier orden sin sobrescribir los métodos de cada uno (si tienen nombres diferentes). Así que siempre obtendrás un objeto FOO que tiene los métodos skateboard y donut (¡Yay!).

#2 Definiendo un nuevo objeto

Si has leído el primer ejemplo, entonces ya sabes cuál es el propósito del || {}.

Porque si no existe un objeto FOO entonces el OR-case se convertirá activa y crea un nuevo objeto, para que pueda asignarle funciones. Como:

var FOO = {};

FOO.skateboard = function() {
  alert('I like skateboarding!');
};

Si no hay ningún valor en AEROTWIST o es nulo o indefinido, el valor asignado al nuevo AEROTWIST será {} (un objeto en blanco)

El operador || toma dos valores:

a || b

Si a es verdadero, volverá a. De lo contrario, volverá b.

El falsy valores son null, undefined, 0, "", NaN y false. Los valores de verdad son todo lo demás.

Así que si a no se ha establecido (es undefined) volverá b.

Observe que en alguna versión de IE este código no funcionará como se espera. Debido a que el var, la variable se redefine y asignado de modo – si recuerdo correctamente el problema – que va a terminar para tener siempre un nuevo objeto. Eso debería solucionar el problema:

var AEROTWIST;
AEROTWIST = AEROTWIST || {};