Em meu primeiro emprego como engenheiro de software, pensei que tinha um bom conhecimento de como desenvolver bons aplicativos ou sistemas desde que aprendi a codificar no ensino médio. Então, eu sou bastante otimista naquela época. Na verdade, não prestei muita atenção à qualidade do meu código. E por causa disso, no desenvolvimento seguinte, fiquei muito frustrado por causa do meu próprio código. Não é legível e não é fácil de manter.

Então comecei a perceber que um bom sistema não começa com uma boa interface, ótimos recursos e coisas complicadas. Bons sistemas começam com sua boa qualidade de código.

Depois de um tempo, pedi aos engenheiros seniores da época que me dessem sugestões sobre como melhorar a qualidade do meu código. E, finalmente, eles me deram uma das boas abordagens mais conhecidas em programação, chamada Clean Code .

Acontece que melhorar a qualidade do nosso código não é tão difícil. Nós apenas temos que deixar o código limpo. Limpar significa remover todas as coisas complicadas e torná-las simples e legíveis.

Então, neste post, deixe-me compartilhar o que eu pessoalmente faço para manter a qualidade do meu código e darei alguns exemplos que tirei do Clean Code de Robert J. Martin . É um livro de programação. Sugiro que você explore mais sobre código limpo nesse livro para obter mais detalhes.

Use nomes descritivos

Podemos começar pelos nomes. Os nomes das variáveis ​​e das funções devem ser o mais descritivos possível. Não use abreviações ou nomes que não sejam significativos. Aqui está um exemplo de nomes ruins e bons.

Nomes ruins ❌

const fn = 'Farizal';
const ln = 'Hamami';

function full() {
    return fn + ln;
}

const firstName = 'Farizal';
const lastName = 'Hamami';

function getFullName() {
    return firstName + lastName;
}

— Robert C. Martin

Tente evitar o uso de comentários

Imagine se tivermos que manter os comentários enquanto mantemos o código também. Vai desperdiçar nosso tempo. Em vez disso, o próprio código deve ser informativo.

Código ruim ❌

// Check to see if the employee
// is eligible for full benefits
if ((employee.flags & HOURLY_FLAG) && (employee.age > 65))

if (employee.isEligibleForFullBenefits())

Comentário redundante ❌

// Declare first name
const firstName = 'Farizal';

// Declare last name
const lastName = 'Hamami';

/**
  Get full name by combining
  first name and last name
*/
function getFullName() {
    return firstName + lastName;
}

Comentário informativo ✅

// SimpleDateFormat is not thread-safe,
// so we need to create each instance independently.
const dateFormat = new SimpleDateFormat(
  ”EEE, dd MMM yyyy HH:mm:ss z”);
df.setTimeZone(TimeZone.getTimeZone(”GMT”));

No entanto, não exigimos um comentário se nosso código for compreensível. Se criarmos um comentário e alguém precisar alterar o código, não podemos confirmar se essa pessoa também atualizou o comentário. É por isso que precisamos evitar o uso de comentários sempre que possível.

Dê um nome de função consistente

Apesar de serem descritivos, os nomes das funções também devem ser consistentes. Isso fará com que o código pareça organizado e nos ajudará a encontrar funções mais facilmente, pois podemos examinar rapidamente a base de código procurando por um nome específico.

Nomes inconsistentes ❌

class Circle {
    public function getRadius() {...}
    public function fetch_color() {...}
    public function retrieveArea() {...}
}

class Circle {
    public function getRadius() {...}
    public function getColor() {...}
    public function getArea() {...}
}

Reduzir caracteres em uma linha

Lembre-se de que queremos criar um código fácil de ler e devemos evitar longas linhas de código dividindo os caracteres em novas linhas.

Muito tempo ❌

throw ValidationException::withMessages(['email' => trans('auth.failed'), 'error' => 'Your password is incorrect', 'redirect' => true]);

throw ValidationException::withMessages([
    'email' => trans('auth.failed'),
    'error' => 'Your password is incorrect',
    'redirect' => true
]);

Sei que é tentador resolver nosso problema com uma única função e criamos uma função que faz muitas coisas. Acho que devemos evitar fazer isso para minimizar a complexidade da função.

Função complexa ❌

function createAppointment(appointment) {
    const patientList = this.$api.get('patient');
    const currentPatient = patientList.find((patient) => {
        patient.id = appointment.patient_id
    });
    const selectedDoctor = doctorList.find((doctor) => {
        doctor.id = appointment.doctor_id
    });
    const selectedLocation = locationList.find((location) => {
        location.id = appointment.location_id
    });
    this.sendAppointment(selectedDoctor, selectedDoctor, currentPatient);
}

function createAppointment(appointment) {
    const currentPatient = getCurrentPatient(this.patientId);
    this.sendAppointment(
      appointment,
      currentPatient
    );
}

— Robert C. Martin

Fora isso, acho que usar muitos parâmetros também é uma má ideia, pois dificultará a manutenção dessa função em muitos lugares diferentes. Então seria bom se pudéssemos minimizar os parâmetros da função.

function buildCar(float wheelDiameter, float wheelColor, float wheelMaterial, float wheelManufacturer, String engineType, String engineColor, String engineManufacturer);

function buildCar(Wheel wheel, Engine engine);

Havia algumas preocupações de formatação de código naquela época, cada desenvolvedor tem sua própria formatação de código. Não sei qual formato de escrita devo seguir e qual é a formatação mais ideal para escrever código.

Felizmente, existem convenções de formatação na abordagem de Código Limpo. Acho que, nesse caso, precisamos fazer o acordo, então seria bom se todos os desenvolvedores seguissem esse cenário .

Variáveis

As variáveis ​​devem ser declaradas o mais próximo possível de seu uso.

function paySalary(Employee employee) {
    const bonus = calculateBonus(employee);
    const totalSalary = bonus + employee.getSalary();
    sendMoney(employee, totalSalary);
}

public class Employee {
    private String name;
    private String id;
    private float salary;
    
    public function getName() { ... }
}

As funções dependentes devem estar próximas verticalmente.

function paySalary() {
    calculateBonus(salary);
}

function calculateBonus(salary) {
    return (salary / 10);
}

class Employee {
    public function payTax() {}

    public function payOverdueTax(date) {}

    public function increaseSalary() {}

    public function decreaseSalary() {}
}

Muitos desenvolvedores estão tentando fazer o alinhamento horizontal de seu código igual ao de outra linha de código.

public class WebService {
    private    Request         request;
    private    Response        response;
    private    FitnesseContext context;
    protected. long            requestTimeLimit;
}

public class WebService {
    private Request request;
    private Response response;
    private FitnesseContext context;
    protected long requestTimeLimit;
}

A maneira mais simples de tornar nosso código legível é prestando atenção ao recuo de nosso código. Aqui está um exemplo.

public String functionName() {return "";}

public String functionName() {
    return "";
}

Em primeiro lugar, obrigado por ler este artigo. Acho o artigo bem longo. Mas espero que seja útil para desenvolvedores, especialmente para aqueles que são novos neste mundo técnico.

Quero fazer algumas palavras para encerrar isso e diria que a qualidade do código é uma das coisas mais importantes que precisamos cuidar como desenvolvedor. Caso contrário, custaríamos nosso tempo no futuro, pior ainda, custaria muito à organização e às equipes. E podemos começar a melhorar a qualidade do nosso código implementando um código limpo .

O código limpo não só traz benefícios para você, mas também melhora a produtividade das equipes ou de qualquer pessoa envolvida nos projetos. Seu código será mais compreensível, legível e fácil de manter. E acho que é uma habilidade crucial que todo desenvolvedor deve dominar.