Práticas recomendadas / razões para constantes String em JavaScript [fechado]

Em linguagens estáticas como Java / C #, geralmente uso constantes para cadeias ou números, em vez de inseri-las somente no código. No entanto, costumo evitar essa prática em JavaScript. Mais recentemente, como alguns outros codificadores ao meu redor adotaram essa abordagem no JS, decidi que provavelmente deveria solidificar meu raciocínio, ou o deles.

Não há sintaxe de declaração "const" real no JavaScript. Geralmente, apenas aceitamos uma política informal de não alterar as propriedades em maiúsculas. Mas minha opinião é geralmente evitá-los completamente, porque a maioria de seus benefícios se perde em JavaScript. Em Java, uma sequência incorreta fará com que o programa falhe ao tentar executá-lo, quando você o corrige e segue em frente. Ter um verificador estático em que ambas as instâncias estão apontando para a mesma constante elimina esse problema, pois ele pode ser encontrado em tempo de compilação. Mas o JavaScript simplesmente terá esse problema em todo o lugar, pois você SEMPRE descobrirá a correção da ortografia no tempo de execução :

Library = { doThing: function() }
setTimeout(function()
  Liberry.doThing()
  // No such object: Liberry
}, 0);

A melhor proteção contra isso, geralmente, é "use strict". Para os desenvolvedores que preferem, eu estou bem com eles usando isso para encontrar problemas com variáveis ​​não declaradas mais rapidamente. Mas minha opinião é que o fornecimento de constantes de string para APIs REST, etc., na verdade não protege você contra nada. Outro exemplo:

CompanyAPI.constants.ENROLL_URL = "/rest/enroll";
CompanyAPI.constants.FIRST_NAME = "firstName";

ajax({url: CompanyAPI.constants.ENROLL_URL,
data: CompanyAPI.constants.FIRST_NAME
});
// vs.
ajax({url: "/rest/enroll",
data: "firstName"
});

... Você pretendia escrever o texto acima, mas depois fez erros de digitação. Ops.

ajax({url: CompanyAPI.constants.ENROL_URL,
  data: CompanyAPI.constants.FIRS_NAME
});
// vs.
ajax({url: "/rest/enrol",
  data: "firsName"
});

O baseado em constante ainda fornecerá indefinido , enquanto "firsName" não é melhor. Para esse fim, costumo ver isso como um benefício de linguagens estáticas, e não me incomodo em ter um sistema para corrigi-lo (além de talvez começar a usar "use strict" para depuração). Outras pessoas podem me dizer qual é a prática preferida para constância de string / número inteiro?

EDIT: Para esclarecer, minha preferência é geralmente colocar seqüências de caracteres como "firstName" diretamente alinhadas, sem declaração constante de nível superior - as penalidades por erros de ortografia são da mesma maneira. Seqüências de caracteres que podem ficar longas, como uma URL REST, tenderei a definir na parte superior do arquivo.

As constantes cumprem uma função de verificação de erros em linguagens estaticamente tipadas, mas também servem a um segundo propósito. Eles centralizam as informações em um só lugar. Isso não se perde quando passamos para o JavaScript.

Imagine que seu exemplo se parece mais com isso,

config.js:

CompanyAPI.constants.ENROLL_URL = "/rest/enroll";
CompanyAPI.constants.FIRST_NAME = "firstName";

register.js:

ajax({url: CompanyAPI.constants.ENROLL_URL,
    data: CompanyAPI.constants.FIRST_NAME
});

special-register.js:

ajax({url: CompanyAPI.constants.ENROLL_URL,
    data: CompanyAPI.constants.FIRST_NAME
});

need-to-register-from-this-other-place.js:

ajax({url: CompanyAPI.constants.ENROLL_URL,
    data: CompanyAPI.constants.FIRST_NAME
});

goto-register.js:

redirect({url: CompanyAPI.constants.ENROLL_URL,
    data: CompanyAPI.constants.FIRST_NAME
});

Observe como, agora, essas constantes estão aparecendo em arquivos em todo o lugar. Se eu não estivesse usando constantes, teria que encontrar todas as instâncias dessa sequência específica e substituí-las manualmente. É certo que há duplicação aqui, mas observe que o último é realmente diferente. Isso significa que, mesmo que removamos a duplicação, não poderíamos abstrair isso. Agora, porque estamos usando constantes e CompanyAPI.constants.FIRST_NAMEprecisa mudar, podemos alterá-lo em um e apenas um lugar, e ele muda automaticamente em todos os lugares.

Se eu estiver usando uma string em apenas um lugar e ela não for configuração (ou seja, um índice de string de matriz não é configuração), colocarei em linha. Se eu achar que estou usando em alguns lugares próximos, procurarei refatorá-lo em um único uso. Se eu não puder refatorar, provavelmente o moveria para uma constante de nível de "classe".

Assim como aprender outro idioma, não se deve compará-lo à sua língua materna. Alguns idiomas costumam ter conceitos que não são encontrados em outros. Simplesmente aprendemos a aceitá-los.

As constantes em Java, C # e C ++ não existem no código binário. Essas constantes foram inventadas para ajudar programadores e compiladores. Como esta resposta ( /programming/130396/are-there-constants-in-javascript ) diz "Nada é sempre constante"

Portanto, a resposta para suas perguntas está na Convenção de Nomenclatura e na Revisão de Código. Você e sua equipe precisarão definir como nomear constantes, concordar que as constantes não serão modificadas e usar a revisão de código como forma de impor a regra. No final do dia, não importa para que lado você decida seguir, não será à prova de idiotas.

Minha maneira preferida de lidar com constantes é

var NAMESPACE.CONSTANT = 1;