Qual é a melhor prática para nomear arquivos Swift que adicionam extensões a objetos existentes?

É possível adicionar extensões aos tipos de objetos Swift existentes usando extensões, conforme descrito na especificação do idioma .

Como resultado, é possível criar extensões como:

extension String {
    var utf8data:NSData {
        return self.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)!
    }
}

No entanto, qual é a melhor prática de nomeação para arquivos de origem Swift que contêm essas extensões?

No passado, a convenção era extendedtype+categoryname.mpara o tipo Objective-C, conforme discutido no guia Objective-C . Mas o exemplo Swift não tem um nome de categoria, e chamá-lo String.swiftnão parece apropriado.

Portanto, a pergunta é: dada a Stringextensão acima , como deve ser chamado o arquivo de origem rápido?

A maioria dos exemplos que vi imitam a abordagem Objective-C. A extensão de exemplo acima seria:

String+UTF8Data.swift

As vantagens são que a convenção de nomenclatura facilita a compreensão de que é uma extensão e qual classe está sendo estendida.

O problema com o uso Extensions.swiftou mesmo StringExtensions.swifté que não é possível inferir a finalidade do arquivo pelo nome sem examinar o conteúdo.

Usar a xxxable.swiftabordagem usada pelo Java funciona bem para protocolos ou extensões que definem apenas métodos. Mas, novamente, o exemplo acima define um atributo para que UTF8Dataable.swiftnão faça muito sentido gramatical.

Não existe uma convenção Swift. Mantenha simples:

StringExtensions.swift

Eu crio um arquivo para cada classe que estou estendendo. Se você usar um único arquivo para todas as extensões, ele rapidamente se tornará uma selva.

Eu prefiro StringExtensions.swiftaté adicionar coisas demais para dividir o arquivo em algo como String+utf8Data.swifte String+Encrypt.swift.

Mais uma coisa, combinar arquivos semelhantes em um só tornará sua construção mais rápida. Consulte Optimizing-Swift-Build-Times

Se você tiver um conjunto acordado em equipe de aprimoramentos comuns e diversos, agrupá-los como um Extensions.swift funcionará como uma solução de primeiro nível de Manutenção simples. No entanto, à medida que sua complexidade aumenta ou as extensões se tornam mais envolvidas, é necessária uma hierarquia para encapsular a complexidade. Em tais circunstâncias, recomendo a prática a seguir com um exemplo.

Eu tive uma aula que fala com meu back-end, chamada Server. Começou a crescer para cobrir dois aplicativos de destino diferentes. Algumas pessoas gostam de um arquivo grande, mas apenas se separam logicamente com extensões. Minha preferência é manter cada arquivo relativamente curto, então escolhi a seguinte solução. Serveroriginalmente conforme CloudAdapterProtocole implementou todos os seus métodos. O que fiz foi transformar o protocolo em uma hierarquia, fazendo-o se referir a protocolos subordinados:

protocol CloudAdapterProtocol: ReggyCloudProtocol, ProReggyCloudProtocol {
    var server: CloudServer {
        get set
    }
    func getServerApiVersion(handler: @escaping (String?, Error?) -> Swift.Void)
}

Em Server.swiftque tenho

import Foundation
import UIKit
import Alamofire
import AlamofireImage

class Server: CloudAdapterProtocol {
.
.
func getServerApiVersion(handler: @escaping (String?, Error?) -> Swift.Void) {
.
.
}

Server.swiftentão apenas implementa a API do servidor núcleo para configurar o servidor e obter a versão da API. O trabalho real é dividido em dois arquivos:

Server_ReggyCloudProtocol.swift
Server_ProReggyCloudProtocol.swift

Eles implementam os respectivos protocolos.

Isso significa que você precisa ter declarações de importação nos outros arquivos (para Alamofire neste exemplo), mas é uma solução limpa em termos de segregação de interfaces na minha opinião.

Eu acho que essa abordagem funciona igualmente bem com classes especificadas externamente e com as suas próprias.

Por que isso é mesmo um debate? Devo colocar todas as minhas subclasses em um arquivo chamado _Subclasses.swift. Eu acho que não. Swift possui espaçamento de nome baseado em módulo. Para estender uma classe Swift conhecida, é necessário um arquivo específico para sua finalidade. Eu poderia ter uma grande equipe que cria um arquivo que é o UIViewExtensions.swift que não tem propósito algum e confunde os desenvolvedores e pode ser facilmente duplicado no projeto que não seria criado. A convenção de nomenclatura Objective-C funciona bem e até Swift ter espaçamento de nome real, é o melhor caminho a percorrer.

Em vez de adicionar meus comentários em todo o lugar, eu os estou colocando aqui em uma resposta.

Pessoalmente, adoto uma abordagem híbrida que oferece boa usabilidade e clareza, além de não sobrecarregar a área de superfície da API para o objeto que estou estendendo.

Por exemplo, qualquer coisa que faça sentido estar disponível para qualquer string seria StringExtensions.swiftcomo trimRight()e removeBlankLines().

No entanto, se eu tivesse uma função de extensão, como formatAsAccountNumber()ela não entraria nesse arquivo, porque 'Número da conta' não é algo que se aplicaria naturalmente a todas / todas as strings e só faz sentido no contexto das contas. Nesse caso, eu criaria um arquivo chamado Strings+AccountFormatting.swiftou talvez Strings+CustomFormatting.swiftcom uma formatAsAccountNumber()função se houver vários tipos / maneiras de realmente formatá-lo.

Na verdade, nesse último exemplo, eu dissuito ativamente minha equipe de usar extensões como essa em primeiro lugar e, em vez disso, incentivaria algo como AccountNumberFormatter.format(String)isso, pois isso não afeta a Stringárea da superfície da API, como deveria. A exceção seria se você definisse essa extensão no mesmo arquivo em que é usada, mas não teria seu próprio nome de arquivo.

Prefiro +sublinhar o fato de que ele contém extensões:

String+Extensions.swift

E se o arquivo ficar muito grande, você poderá dividi-lo para cada finalidade:

String+UTF8Data.swift

String+Encrypt.swift