javascript - texto - ¿Cuándo debería usar un punto y coma después de las llaves?

uso de la coma ejemplos

Question

Muchas veces he visto un punto y coma utilizado después de una declaración de función, o después de la función anónima de "devolución" de un script de patrón de módulo. ¿Cuándo es apropiado usar un punto y coma después de las llaves?

Answer 1

No use un punto y coma:

... si es solo su declaración de función diaria:

function foo() {

} // No semicolon

Use un punto y coma:

... si es una tarea:

var foo = function() {

}; // Semicolon

... o una función de invocación automática:

(function () {

})(); // Semicolon

Answer 2

Los puntos y coma van al final de las líneas que no terminan en una llave o para separar las declaraciones en la misma línea. No hace daño usarlos después de un corsé de cierre, o usar tirantes y un cinturón, pero se ve un poco nerd.

Answer 3

Nunca necesitas hacerlo; siempre puedes (excepto antes y while else ).

Explicación:

Desafortunadamente, los puntos y comas de Javascript son opcionales.
Por lo tanto, nunca necesita agregar un punto y coma.

Es (muy) buena práctica finalizar cada declaración con un punto y coma.
Las únicas declaraciones que terminan con a } son las declaraciones que terminan con un objeto literal (por ejemplo, JSON) o expresión de función.

Por lo tanto, la mejor práctica es poner punto y coma después de las siguientes dos llaves (solo):

var myFunc = function() { };
var myobject = { };

Answer 4

Sé que este hilo es antiguo pero no pude resistirme a compartir este código:

// this will break code

a=b=c=d=e=1
a = b + c     //semicolon required here
(d + e).toString()

Volverá "Propiedad del objeto [objeto Object] no es una función". Porque en realidad se ejecutará como:

a = b + c(d + e).toString()

Answer 5

Si tenemos una función de autoinvocación, necesitamos poner un punto y coma antes de ella, de lo contrario se convierte en parte de la declaración de asignación anterior. Considera lo siguiente:

testClass = function(name) {
  document.write ("Instantiating testClass<br />");
  this.name = name;
}

testClass.prototype.report = function() {
  document.write ("I''m " + this.name + "<br />");
  return 1;
}

testClass.prototype.testMethod = function(param) {
  document.write ("Running testMethod with parameter value " + param + "<br />");
  return 2;
} // notice that there is no semicolon here

(function() {
  document.write ("Running self-invoking function<br />");
  return 3;
}());

if (typeof(testClass.prototype.testMethod) !== "function") {
  document.write ("testMethod type: " + typeof(testClass.prototype.testMethod));
  document.write (", value: " + testClass.prototype.testMethod + "<br />");
}
var testOb = new testClass("Bill");
testOb.report();
testOb.testMethod(4);

Esto producirá el siguiente resultado:

"Ejecución de la función autoinvocación"
Ejecutando testMethod con el valor del parámetro 3
TestMethod tipo: número, valor: 2
Instanciando testClass
Soy Bill "

... más un error de JavaScript informado por el navegador: testOb.testMethod is not a function

Esto ciertamente no es lo que pretendíamos. ¿Por qué testMethod ejecuta inmediatamente antes de que hayamos instanciado la clase? ¿Y por qué ya no existe cuando queremos llamarlo como método miembro?

Lo que está sucediendo es que testMethod se está asignando no a nuestra definición de función, sino al valor de retorno de la definición de la función. Y la definición de la función en sí misma se está ejecutando de forma anónima. Así es como:

1. El constructor testClass y el report método miembro se definen / asignan con éxito.
2. Debido a la falta de un punto y coma después de la definición de testMethod , el () rodea la siguiente función de invocación automática se convierte en un operador de invocación, lo que hace que nuestra definición de testMethod convierta en una función anónima que se invoca inmediatamente. el valor de retorno de la siguiente función anónima se convierte en su lista de parámetros. Esto explica el orden de la salida impresa: nuestra función de invocación automática se ejecuta primero, ya que se evalúa como un parámetro.
3. Dado que nuestra definición de función prevista devuelve 2, es este 2 el que se asigna a testMethod , y no la definición de la función. Esto es confirmado por nuestra impresión del tipo y valor de testMethod .
4. Ahora testClass se testClass una instancia exitosa como testOb y su método de report funciona según lo previsto, lo que demuestra que la definición de la clase está intacta.
5. Cuando intentamos llamar a testMethod , el testMethod nos dice que no es una función, y con razón, porque es un número con el valor 2.
   

Si ponemos un punto y coma después de la definición de testMethod , separará su asignación de la llamada de la función de invocación automática, y tendremos el resultado que esperábamos:

"Ejecución de la función autoinvocación"
Instanciando testClass
Soy Bill
Ejecutando testMethod con el valor de parámetro 4 "

O podríamos incluso ponerlo directamente antes de la función anónima:

;(function() {...

Pero sugiero que, dado que el problema se debe a la falta de un punto y coma al final de una declaración de asignación, tal vez deberíamos hacernos el hábito de poner siempre un punto y coma después de definir las funciones de esta manera. es decir, todas mis funciones anteriores deben tener un punto y coma después de la llave de cierre, porque todas son asignaciones de funciones anónimas.

Answer 6

También debe usar un punto y coma después de un corchete después de devolver una función dentro de una función en Javascript.

function watchOut(problem) {
  return function(number, location) { 
    alert("Be careful! There are " + problem +
          " today!/n" +

          number + " have been spotted at the " + location + "!"
    );
  };
}

Answer 7

También importa cuando intenta minificar su código.

Así que personalmente agregué uno después de cada } donde ASI insertaría uno.

Escribí una publicación sobre ASI en JavaScript .

Answer 8

Usas un punto y coma después de una declaración. Esta es una declaración:

var foo = function() {
  alert("bar");
};

porque es una asignación variable (es decir, crear y asignar una función anónima a una variable).

Las dos cosas que vienen a la mente que no son declaraciones son declaraciones de funciones:

function foo() {
  alert("bar");
}

y bloques:

{
  alert("foo");
}

Nota: esa misma construcción de bloque sin punto y coma también se aplica a los bucles for , do y while.