5 dicas para escrever um código mais limpo

Quando você está escrevendo código, é importante estar atento às suas práticas de codificação. Isso significa dedicar um tempo para escrever um código limpo e organizado que seja fácil para outras pessoas lerem e entenderem. Aqui estão cinco dicas para ajudá-lo a começar:

1. Evite aninhamento desnecessário

Aninhar no código é algo que fazemos o tempo todo e, embora não haja nada inerentemente errado com o aninhamento, às vezes pode tornar o código mais difícil de ler. Uma abordagem para ajudar a evitar isso é usar o padrão de design “Return Early”. Ele nos permite usar a instrução if como uma cláusula de guarda para verificar erros e retornar antes de executar qualquer código adicional. Isso ajuda a evitar o uso de if/else e aninhamento desnecessário.

Assim:

• Antes da

function deleteItem(item) {
  if (item != null) {
    console.log("Deleting item");
    item.delete();
  }
}

• Depois

function deleteItem(item) {
  if (item == null) return;

  console.log("Deleting item");
  item.delete();
}

Como você pode ver, a segunda implementação é obviamente mais limpa, essa abordagem pode ajudar a tornar seu código mais linear , mais limpo e mais legível . É uma técnica simples e fácil de implementar .

2. Desestruturação de Objetos para Parâmetros de Função

Vamos supor que temos uma função que recebe um objeto como parâmetro e realiza algum tipo de operação nesse objeto para retornar um novo valor. Sem usar a desestruturação de objetos, podemos obter algo assim:

// not so good
function getFullName(person) {
  const firstName = person.firstName;
  const lastName = person.lastName;
  return `${firstName} ${lastName}`;
}

Essa implementação funciona bem, mas uma maneira melhor de implementar isso é usar a desestruturação de objetos. Podemos destruir o objeto pessoa para obter o nome e o sobrenome em uma linha:

// better
function getFullName(person) {
  const { firstName, lastName } = person;
  return `${firstname} ${lastName}`;
}

3. Usando funções puras

Funções puras são uma ótima maneira de escrever código fácil de ler e entender. Ao usar funções puras, você pode evitar a criação de código complexo e difícil de seguir. Funções puras sempre retornam o mesmo resultado com a mesma entrada, o que as torna previsíveis e confiáveis. Além disso, funções puras são fáceis de testar e depurar, tornando-as ideais para uso em projetos de desenvolvimento de software.

// bad
let items = 5;
function changeNumber(number) {
  items = number + 3;
  return items;
}
changeNumber(5);

// good
function addThree(number) {
  return number + 3;
}

4. Mantenha as funções simples

Há muita sabedoria em manter as funções simples. Quando você mantém suas funções pequenas e focadas, é mais fácil entender o que elas fazem e como funcionam. Isso os torna menos propensos a erros e mais fáceis de manter. Além disso, quando você mantém seu código modular, fica mais fácil reutilizar funções individuais em diferentes contextos.

function signUpAndValidate() {
// Do a stuff here
}

É melhor manter as funções responsáveis ​​por apenas uma coisa. Esta é uma abordagem melhor:

function signUp() {
}
function validate() {
}

Resumindo, manter suas funções simples resulta em um código melhor que é mais fácil de entender e manter . Então, da próxima vez que você se deparar com o desafio de escrever algum código, lembre-se de manter as coisas simples!

5. Use nomes de variáveis ​​significativos

Use nomes de variáveis ​​significativos. Isso torna seu código mais legível e mais fácil de depurar. Por exemplo, não use x ou y como variáveis; use algo que descreva para que serve a variável, como currentWidth ou inputValue.

// bad
let x = 0;
let y = 1;

// good
let currentWidth = 0;
let inputValue = 1;