18.11.2024

Aula 63: Melhores Práticas e Padrões de Codificação em Swift

Escrever código limpo, manutenível e eficiente é essencial para qualquer desenvolvedor, especialmente em uma linguagem como Swift, que é utilizada para desenvolver aplicações iOS, macOS, watchOS e tvOS. Nesta aula, abordaremos as melhores práticas e padrões de codificação que podem ajudá-lo a melhorar suas habilidades de programação em Swift.

1. Utilize Convenções de Nomenclatura Significativas

Escolher nomes significativos para variáveis, funções e classes é crucial para a legibilidade do código.

// Nome ruim
var x: Int = 10
func fn1() {}

// Nome bom
var numeroDeUsuarios: Int = 10
func buscarDadosDoUsuario() {}

Diretrizes:

• Use nomes descritivos que transmitam o propósito da variável ou função.
• Use camelo (camel case) para variáveis e funções. Para tipos e protocolos, use Pascal case.

2. Organize o Código com Extensões

Extensões permitem que você modularize seu código e melhore a legibilidade.

// Sem extensão
class Carro {
    var modelo: String
    var ano: Int

    init(modelo: String, ano: Int) {
        self.modelo = modelo
        self.ano = ano
    }

    func ligarMotor() {
        print("Motor ligado")
    }

    func desligarMotor() {
        print("Motor desligado")
    }
}

// Com extensão
class Carro {
    var modelo: String
    var ano: Int

    init(modelo: String, ano: Int) {
        self.modelo = modelo
        self.ano = ano
    }
}

// Extensão para funções do Motor
extension Carro {
    func ligarMotor() {
        print("Motor ligado")
    }

    func desligarMotor() {
        print("Motor desligado")
    }
}

Diretrizes:

• Use extensões para organizar o código relacionado a funcionalidades específicas.
• Agrupe métodos semelhantes juntos.

3. Utilize Instruções Guard para Saída Antecipada

Usar instruções guard pode ajudar a simplificar seu código lidando com condições que levam a uma saída antecipada.

func processarEntradaDoUsuario(entrada: String?) {
    guard let entradaValida = entrada, !entradaValida.isEmpty else {
        print("Entrada inválida")
        return
    }

    print("Processando entrada: \(entradaValida)")
}

Diretrizes:

• Use guard para condições que devem ser atendidas para prosseguir.
• Mantenha a lógica principal da sua função indentada e clara.

4. Prefira Structs a Classes

Swift incentiva o uso de tipos de valor (structs) em vez de tipos de referência (classes), a menos que você precise de semântica de referência.

// Usando Struct
struct Usuario {
    var nome: String
    var idade: Int
}

// Usando Classe
class UsuarioClasse {
    var nome: String
    var idade: Int
    init(nome: String, idade: Int) {
        self.nome = nome
        self.idade = idade
    }
}

Diretrizes:

• Use structs quando quiser encapsular dados relacionados e seu comportamento.
• Opte por classes apenas quando precisar de herança ou semântica de tipo de referência.

5. Mantenha Funções Pequenas e Focadas

Uma função deve idealmente realizar uma única tarefa ou responsabilidade. Manter funções pequenas melhora a legibilidade e a manutenibilidade.

// Exemplo ruim
func processarUsuarioEEnviarRelatorio(usuario: Usuario) {
    // Buscar dados do usuário
    // Processar dados
    // Gerar relatório
    // Enviar relatório
}

// Bom exemplo
func buscarDadosDoUsuario(usuario: Usuario) {
    // Buscar dados do usuário
}

func processarDadosDoUsuario(dados: DadosDoUsuario) {
    // Processar dados
}

func enviarRelatorio(relatorio: Relatorio) {
    // Enviar relatório
}

Diretrizes:

• Se uma função for muito longa, considere dividi-la em funções auxiliares menores.
• Cada função deve idealmente caber em uma única visualização em seu IDE.

6. Aproveite o Tratamento de Erros do Swift

Use o tratamento de erros embutido do Swift para gerenciar exceções de forma mais elegante.

enum ErroDeDados: Error {
    case dadosInvalidos
}

func buscarDados() throws -> String {
    throw ErroDeDados.dadosInvalidos
}

do {
    let dados = try buscarDados()
    print(dados)
} catch ErroDeDados.dadosInvalidos {
    print("Erro: Dados inválidos capturados.")
}

Diretrizes:

• Crie tipos de erro específicos para representar várias condições de erro.
• Utilize do-catch para tratar erros de forma elegante.

7. Comente com Sabedoria

Os comentários devem explicar "por que" algo foi feito, e não "o que" foi feito, uma vez que o código deve ser autoexplicativo quando escrito claramente.

// Comentário ruim
// Incrementando contagem
contagem += 1

// Bom comentário
// Incrementa contagem do usuário após login bem-sucedido
contagem += 1

Diretrizes:

• Escreva comentários que adicionem valor e contexto à lógica complexa.
• Use comentários para explicar por que certas decisões foram tomadas, e não para reiterar o código.

Conclusão

Seguindo estas melhores práticas e padrões de codificação, você poderá escrever código Swift mais limpo e manutenível. Lembre-se de que clareza e organização não apenas o ajudarão, mas também a outros que podem trabalhar em seu código no futuro. Boas codificações!

Video

Navigation