Neste tutorial, mostraremos uma visão geral básica das extensões em Swift. Demonstraremos como Extensões Swift funcionam por construção um aplicativo de monitoramento de treino simples.
Vamos nos concentrar no seguinte:
- O que são extensões Swift?
- Criação de uma extensão em Swift
- Propriedades de tipo
- Métodos mutantes
- Código de separação
- Extensão para visualizações SwiftUI
- Adicionando inicializadores a tipos existentes
O que são extensões Swift?
As extensões, bem, estendem os tipos nomeados Swift existentes-ou seja, structs, classes, enums e protocolo-para que você possa adicionar mais funcionalidade a eles. Isso permite que você insira seu próprio código no código do sistema existente ao qual você não teria acesso, como Estrutura básica . Você também pode usar extensões para estender seu próprio código e para limpeza de código.
Criação de uma extensão em Swift
Criar extensões é semelhante a criar tipos nomeados em Swift. Ao criar uma extensão, você adiciona a palavra extensão antes do nome.
extension SomeNamedType { //Estendendo SomeNamedType e adicionando novo //funcionalidade para ele.
}
Propriedades de tipo
Você pode estender um determinado tipo nomeado, adicionar uma nova instância computada e digitar propriedades a ela. Por exemplo, você pode estender Cor para adicionar suas próprias cores a ele. Digamos que nosso aplicativo tenha uma cor de marca que queremos usar em qualquer lugar. Poderíamos criar uma propriedade de tipo constante, marca , estendendo Cor por meio de extensão .
Nosso aplicativo também usa cores personalizadas para o plano de fundo da linha na tela de configurações. Para isso, definiremos uma propriedade de tipo variável que ajusta a cor de acordo com a aparência do sistema.
extensão Cor { marca let estática=Cor (vermelho: 75/255, verde: 0, azul: 130/255) static var settingsBackground: Color { Cor (UIColor {(trait)-> UIColor em return trait.userInterfaceStyle==.dark?.systemGray5:.systemGray6 }) }
}
Veja como você o usa:
struct SettingsRow: View { var title: String var body: some View { HStack (espaçamento: 8) { Texto (título) .foregroundColor (.brand) Espaçador() Imagem (systemName:"chevron.right") } .foregroundColor (.settingsBackground) }
}
Métodos mutantes
Conforme mencionado na introdução, você pode estender os tipos para adicionar sua própria funcionalidade, mesmo que não tenha acesso à base de código original. Se quiser adicionar uma função a Double , por exemplo, você pode escrever uma extensão na estrutura sem ter acesso ao código original da estrutura Double .
Em nosso aplicativo, buscamos dados de calorias do HealthKit, mas a função retorna os dados no tipo Double . Queremos mostrar os dados arredondados para uma casa decimal. Podemos escrever uma extensão em Double como esta:
extension Double { função mutante roundTo (places: Int) { deixe divisor=pow (10,0, duplo (casas)) self=(self * divisor).rounded ()/divisor }
}
Vamos usar este método mutante para resolver nosso problema:
var caloriasBurned: Double?=213,3244 se var calorias=calorias queimadas { calorias.roundTo (lugares: 1) print ("\ (calorias) kcal")///Imprime"213,3 kcal"
}
Código de separação
Ao conformar nossas classes aos protocolos, geralmente adicionamos todos os métodos de protocolo na mesma classe. Por exemplo, adicionaríamos todos os métodos de UICollectionViewDataSource , UICollectionViewDelegate e UICollectionViewDelegateFlowLayout .
Podemos separar os métodos necessários para cada um usando extensões. Isso torna o código mais legível e mais sustentável.
classe ExampleViewController: UIViewController { //Adicionar o código principal vai aqui
} //MARK:-UICollectionViewDataSource
extensão ExampleViewController: UICollectionViewDataSource { func collectionView (_ collectionView: UICollectionView, numberOfItemsInSection section: Int)-> Int { // } func collectionView (_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath)-> UICollectionViewCell { // }
} //MARK:-UICollectionViewDelegate
extensão ExampleViewController: UICollectionViewDelegate { //
} //MARK:-UICollectionViewDelegateFlowLayout
extensão ExampleViewController: UICollectionViewDelegateFlowLayout { //
}
Nosso aplicativo usa o Google Sign-In como a principal fonte de autenticação, então precisamos estar em conformidade com GIDSignInDelegate para receber atualizações sobre o login bem-sucedido. Podemos separar o código necessário para isso-você adivinhou-usando extensões.
import GoogleSignIn classe AuthenticationViewModel: NSObject, ObservableObject { ///O código principal vai aqui
} //MARK:-GIDSignInDelegate
extensão AuthenticationViewModel: GIDSignInDelegate { func sign (_ signIn: GIDSignIn !, didSignInFor user: GIDGoogleUser !, withError error: Error!) { se erro==nulo { //Autenticação bem-sucedida } senão { imprimir (error.debugDescription) } }
}
Extensão em visualizações SwiftUI
Agora, digamos que queremos adicionar um texto de título grande personalizado como o que a Apple usa para o cabeçalho na maioria de seus aplicativos. Este texto denotará a data de um determinado exercício. Queremos usar o texto personalizado exato para a tela de configurações também.
Para reutilizar este trecho de código em qualquer lugar da base de código, estenderemos Texto adicionando um método largeTitle (:) .
extension Text { função largeTitle ()-> some View { auto .negrito() .foregroundColor (.primary) .font (.largeTitle) .frame (maxWidth:.infinity, alinhamento:.leading) .padding (.top, 37) }
}
Agora podemos usar este método em nossas visualizações:
VStack { Texto ("Configurações"). LargeTitle ()
}
Da mesma forma, digamos que queremos criar um botão de coração para marcar um conjunto de exercícios como favorito. Vamos criar um ViewModifier que alterna a cor do coração ao tocar duas vezes:
struct HeartButtonModifier: ViewModifier { @Binding var state: Bool func body (content: Content)-> some View { contente .foregroundColor (estado?.red:.secondary) .onTapGesture (contagem: 2) { state.toggle () } }
}
Agora vamos criar uma extensão em View para que possamos usá-la em nossas visualizações:
extensão Exibir { func treinoLiked (state: Binding )-> some View { self.modifier (HeartButtonModifier (state: state)) }
}
Finalmente, vamos adicioná-lo como um modificador à Imagem :
struct LikeView: View { @State private var state=false var body: some View { Imagem (systemName:"heart.fill") .workoutLiked (estado: $ state) }
}
Adicionando inicializadores aos tipos existentes
Podemos usar uma extensão para adicionar um novo inicializador personalizado que aceita parâmetros diferentes para os tipos existentes.
Suponhamos que seu designer forneça as cores em hexadecimal em vez do valor RGB. Usando os exemplos anteriores de adição de uma propriedade de tipo computado a Color , criaremos um inicializador que recebe um valor hexadecimal. Podemos adicionar outro inicializador se quisermos fazer uma cor com o valor RGB como inteiros:
extensão Cor { init (hex: Int) { deixe vermelho=(hex >> 16) & 0xFF deixe verde=(hex >> 8) & 0xFF deixe azul=hex & 0xFF self.init (vermelho: vermelho, verde: verde, azul: azul) } init (vermelho: Int, verde: Int, azul: Int) { deixe vermelho=duplo (vermelho)/255 deixe verde=duplo (verde)/255 let blue=Double (blue)/255 self.init (vermelho: vermelho, verde: verde, azul: azul, opacidade: 1,0) }
}
Agora podemos usá-lo como:
extensão Cor { marca var estática: Cor { Cor (hex: 0x4B0082) } static var secondaryBrand: Color { Cor (vermelho: 41, verde: 0, azul: 71) }
}
Conclusão
As extensões em Swift são uma maneira poderosa de adicionar sua própria funcionalidade a tipos que você não possui. Esta visão geral das extensões e os exemplos aqui contidos são projetados para ajudá-lo a entender como as extensões funcionam para que você possa implementá-las e usá-las em seus próprios projetos Swift.
Para uma leitura mais avançada, recomendo os seguintes artigos da documentação do Swift:
- “ Adicionando conformidade de protocolo com uma extensão ”
- “ Extensões com uma cláusula Where genérica ”
A postagem Extensões Swift: uma visão geral com exemplos apareceu primeiro no LogRocket Blog .
