Práticas recomendadas de JavaScript
Evite variáveis globais, evite new, evite ==, eviteeval()
Evite variáveis globais
Minimize o uso de variáveis globais.
Isso inclui todos os tipos de dados, objetos e funções.
Variáveis e funções globais podem ser substituídas por outros scripts.
Em vez disso, use variáveis locais e aprenda a usar closures .
Sempre Declare Variáveis Locais
Todas as variáveis usadas em uma função devem ser declaradas como variáveis locais .
As variáveis locais devem ser declaradas com a var
palavra-chave ou a palavra- letchave, ou a palavra- constchave, caso contrário, elas se tornarão variáveis globais.
O modo estrito não permite variáveis não declaradas.
Declarações no topo
É uma boa prática de codificação colocar todas as declarações no início de cada script ou função.
Isso vai:
- Dê um código mais limpo
- Forneça um único local para procurar variáveis locais
- Tornar mais fácil evitar variáveis globais indesejadas (implícitas)
- Reduza a possibilidade de novas declarações indesejadas
// Declare at the beginning
let firstName, lastName, price, discount, fullPrice;
// Use later
firstName = "John";
lastName = "Doe";
price = 19.90;
discount = 0.10;
fullPrice = price - discount;
Isso também vale para variáveis de loop:
for (let i = 0; i < 5; i++)
{
Inicializar variáveis
É uma boa prática de codificação inicializar variáveis ao declará-las.
Isso vai:
- Dê um código mais limpo
- Forneça um único local para inicializar variáveis
- Evite valores indefinidos
// Declare and initiate at the beginning
let firstName = "",
let lastName = "",
let price = 0,
let discount = 0,
let fullPrice = 0,
const myArray = [],
const myObject = {};
A inicialização de variáveis fornece uma ideia do uso pretendido (e do tipo de dados pretendido).
Declare objetos com const
Declarar objetos com const evitará qualquer mudança acidental de tipo:
Exemplo
let car = {type:"Fiat", model:"500", color:"white"};
car = "Fiat"; // Changes object to string
const car = {type:"Fiat", model:"500", color:"white"};
car = "Fiat"; // Not possible
Declare Arrays com const
Declarar arrays com const evitará qualquer mudança acidental de tipo:
Exemplo
let cars = ["Saab", "Volvo", "BMW"];
cars = 3; // Changes array to number
const cars = ["Saab", "Volvo", "BMW"];
cars = 3; // Not possible
Não use new Object()
- Usar
""em vez denew String() - Usar
0em vez denew Number() - Usar
falseem vez denew Boolean() - Usar
{}em vez denew Object() - Usar
[]em vez denew Array() - Usar
/()/em vez denew RegExp() - Usar
function (){}em vez denew Function()
Exemplo
let x1 = ""; // new primitive string
let x2 = 0; // new primitive number
let x3 = false; // new primitive boolean
const x4 = {}; // new object
const x5 = []; // new array object
const x6 = /()/; // new regexp object
const x7 = function(){}; // new function object
Cuidado com as conversões automáticas de tipo
JavaScript é livremente tipado.
Uma variável pode conter todos os tipos de dados.
Uma variável pode alterar seu tipo de dados:
Exemplo
let x = "Hello"; // typeof x is a string
x = 5; // changes typeof x to a number
Esteja ciente de que os números podem acidentalmente ser convertidos em strings ou NaN(Not a Number).
Ao fazer operações matemáticas, o JavaScript pode converter números em strings:
Exemplo
let x = 5 + 7; // x.valueOf() is 12, typeof x is a number
let x = 5 + "7"; // x.valueOf() is 57, typeof x is a string
let x = "5" + 7; // x.valueOf() is 57, typeof x is a string
let x = 5 - 7; // x.valueOf() is -2, typeof x is a number
let x = 5 - "7"; // x.valueOf() is -2, typeof x is a number
let x = "5" - 7; // x.valueOf() is -2, typeof x is a number
let x = 5 - "x"; // x.valueOf() is NaN, typeof x is a number
Subtrair uma string de uma string não gera um erro, mas retorna NaN(Not a Number):
Exemplo
"Hello" - "Dolly" // returns NaN
Usar === Comparação
O ==operador de comparação sempre converte (em tipos correspondentes) antes da comparação.
O ===operador força a comparação de valores e tipo:
Exemplo
0 == ""; // true
1 == "1"; // true
1 == true; // true
0 === ""; // false
1 === "1"; // false
1 === true;
// false
Usar padrões de parâmetro
Se uma função for chamada com um argumento ausente, o valor do argumento ausente será definido como
undefined.
Valores indefinidos podem quebrar seu código. É um bom hábito atribuir valores padrão aos argumentos.
Exemplo
function myFunction(x, y) {
if (y === undefined) {
y = 0;
}
}
ECMAScript 2015 permite parâmetros padrão na definição da função:
function (a=1, b=1) { /*function code*/ }
Leia mais sobre parâmetros e argumentos de função em Parâmetros de Função
Encerre seus switches com padrões
Sempre termine suas switchdeclarações com um default. Mesmo que você ache que não há necessidade disso.
Exemplo
switch (new Date().getDay()) {
case 0:
day = "Sunday";
break;
case 1:
day = "Monday";
break;
case 2:
day = "Tuesday";
break;
case 3:
day = "Wednesday";
break;
case 4:
day = "Thursday";
break;
case 5:
day = "Friday";
break;
case 6:
day = "Saturday";
break;
default:
day =
"Unknown";
}
Evite Number, String e Boolean como Objetos
Sempre trate números, strings ou booleanos como valores primitivos. Não como objetos.
Declarar esses tipos como objetos diminui a velocidade de execução e produz efeitos colaterais desagradáveis:
Exemplo
let x = "John";
let y = new String("John");
(x === y) // is false because x is a string and y is an object.
Ou ainda pior:
Exemplo
let x = new String("John");
let y = new String("John");
(x == y) // is false because you cannot compare objects.
Evite usar eval()
A eval()função é usada para executar texto como código. Em quase todos os casos, não deve ser necessário usá-lo.
Por permitir a execução de código arbitrário, também representa um problema de segurança.