Sintaxis de coma de Javascript

Question

¿Por qué tantos desarrolladores escriben comas de esta manera?

var npm = module.exports = new EventEmitter 
    , config = require("./lib/config") 
    , set = require("./lib/utils/set"); 

No de esta manera?

var npm = module.exports = new EventEmitter, 
    config = require("./lib/config"), 
    set = require("./lib/utils/set"); 

Answer 1

las anotan con el "" al principio de la línea para que sea más fácil mantener el código (añadir o quitar líneas/comente líneas).

Teniendo en cuenta esto:

var npm = module.exports = new EventEmitter 
    , config = require("./lib/config") 
    , set = require("./lib/utils/set"); 

Es mucho más limpio y más fácil de hacer esto:

var npm = module.exports = new EventEmitter 
// , config = require("./lib/config") 
    , set = require("./lib/utils/set"); 

, así como añadir nuevas líneas de la siguiente manera:

var npm = module.exports = new EventEmitter 
    , config = require("./lib/config") 
    , anothervalue = require("./lib/aval") 
    , anothervalue2 = require("./lib/aval2") 
    , set = require("./lib/utils/set"); 

Answer 2

nunca vi que patrón anterior en JS, así que no estoy seguro de si hay que muchos desarrolladores que usted sí, pero supongo que lo hacen para que los nombres de las variables estén alineados, para enfatizar que var realmente define tres variables en su código de muestra.

Si ese es el caso, sin embargo, sería más clara (y menos raro) utilizar sólo var tres veces:

var npm = module.exports = new EventEmitter; 
var config = require("./lib/config"); 
var set = require("./lib/utils/set"); 

Answer 3

Esta es estrictamente una preferencia syntaxtual-programador específico. Conozco a muchos DBA que prefieren este método, mientras yo prefiero la coma final. no hay diferencia real, excepto por preferencia/educación personal.

Answer 4

var npm = module.exports = new EventEmitter
config = require("./lib/config") // ,
//anothervalue = require("./lib/aval"),
//anothervalue2 = require("./lib/aval2"),
set = require("./lib/utils/set");
Ver el extra "//" ... que habría que añadir el "//" a una línea existente al final, así como agregarlo a la siguiente línea ...

Answer 5

EDIT 2: La pregunta anterior me llevó a rascar una picazón que me ha molestado por algún tiempo. Después de un poco de reflexión, he encontrado una buena justificación para las comas iniciales: detectar fácilmente las comas que faltan. Esta es una fuente potencialmente desagradable de errores, ya que, en lugar de quejarse, el compilador sólo tiene que añadir un punto y coma, cambiando así el significado de manera espectacular:

var a = foo(), 
    b = bar() // Oops... 
    c = baz(); // Ouch! 

La tercera línea ya no se inicializa una nueva variable en el ámbito actual . Se asigna a una variable existente en un ámbito externo o inicializa una nueva variable global si no hay una.

Esto no explica el uso de comas iniciales en JSON. Tal vez simplemente se transfirió por decreto.

Dicho esto, todavía prefiero las declaraciones por separado, que lo hacen todo simple y seguro.

Dejaré mi diatriba en su lugar para la posteridad.

---

Acepto que aparece por todas partes. Casi cada segunda biblioteca que examino usa esta convención. Francamente, no lo entiendo.

Las comas al final hacen que sea incómodo comentar la última línea de un grupo ...

var //a = foo(), easy 
    b = bar(), 
    c = baz(); 

var a = foo(), 
    b = bar()/*, awkward 
    c = baz()*/; 

... mientras que conduce comas hacen que sea incómodo para la primera y última línea ...

var /*a = foo() awkward 
    , */b = bar() 
    , c = baz(); 

var a = foo() 
    , b = bar()/* awkward 
    , c = baz()*/; 

Este es el progreso?

(Se podría, por supuesto, ganar un punto barato observando que comas son opcionales, pero esto sólo se logra la paridad a expensas de rechazar a las mejores prácticas.)

Peor aún, las comas que conducen también se utilizan para JSON. Aquí hay un paquete. Json generado por Express.

{ 
    "name": "application-name" 
    , "version": "0.0.1" 
    , "private": true 
    , "dependencies": { 
     "express": "2.5.10" 
    , "jade" : ">= 0.0.1" 
    } 
} 

Este es un PITA porque la mayoría de los editores no les gusta la sangría líneas de hermanos de manera diferente el uno al otro. Tenga en cuenta que la primera línea de un grupo está sangrada más que las siguientes líneas.

El uso de comas líderes me parece una afectación sin sentido que causa problemas sin resolver ninguno. El único argumento en el que puedo pensar que tiene algún mérito es que las comas líderes se alinean entre sí; no muy convincente

Afortunadamente, CoffeeScript se está apoderando del mundo, lo que hace que la pregunta sea discutible (incluso derrota a JSON para la configuración).

EDIT: Se me olvidó mencionar que en realidad no estoy a favor de las comillas finales para el escenario anterior. Creo que declarar vars individuales tiene más sentido. Es limpio, regular y hace que sea muy fácil comentar elementos individuales.

var a = foo(); 
var b = bar(); 
var c = baz();